Make WordPress Core

Ticket #50683: shortcode-parser.1.diff

File shortcode-parser.1.diff, 21.3 KB (added by cfinke, 4 years ago)

Updated diff that vastly improves performance on long text by skipping sections of text that don't have any opening brackets.

  • src/wp-includes/shortcodes.php

     
    214214
    215215        $content = do_shortcodes_in_html_tags( $content, $ignore_html, $tagnames );
    216216
    217         $pattern = get_shortcode_regex( $tagnames );
    218         $content = preg_replace_callback( "/$pattern/", 'do_shortcode_tag', $content );
     217        $shortcode_parser = new Shortcode_Parser( $content, $tagnames );
     218        $content = $shortcode_parser->parse();
    219219
    220220        // Always restore square braces so we don't break things like <!--[if IE ]>.
    221221        $content = unescape_invalid_shortcodes( $content );
     
    224224}
    225225
    226226/**
     227 * A collection of methods for parsing and executing shortcodes in content.
     228 */
     229class Shortcode_Parser {
     230        private $content;
     231        private $state;
     232        private $cursor_position;
     233        private $stack;
     234        private $tagnames;
     235        private $current_shortcode;
     236
     237        const SHORTCODE_PARSE_STATE_DEFAULT          = 0;
     238        const SHORTCODE_PARSE_STATE_IN_TAG           = 1;
     239        const SHORTCODE_PARSE_STATE_IN_CONTENT       = 2;
     240        const SHORTCODE_PARSE_STATE_IN_QUOTED_STRING = 3;
     241
     242        private $DEBUG = false;
     243
     244        public function __construct( $content, $tagnames ) {
     245                $this->content  = $content;
     246                $this->tagnames = $tagnames;
     247        }
     248
     249        /**
     250         * Parse shortcodes in content and replace them with the output that their handler functions generate.
     251         */
     252        public function parse() {
     253                $this->stack = array();
     254
     255                /**
     256                 * A regular expression that checks whether a string appears to begin with a tag for
     257                 * a registered shortcode.
     258                 */
     259                $registered_shortcode_regex= '/^(?P<extra_opening_bracket>\\[?)(?P<opening_bracket>\\[)(?P<tag_slug>' . join( '|', array_map( 'preg_quote', $this->tagnames ) ) . ')(?![\\w-])/u';
     260
     261                $this->cursor_position = 0;
     262
     263                // Save some parsing time by starting a few characters before the first bracket.
     264                $this->forward_cursor_to_next_bracket();
     265
     266                $this->state = self::SHORTCODE_PARSE_STATE_DEFAULT;
     267
     268                $is_escaped = false;
     269                $delimiter = null;
     270
     271                $this->debug( 'Parsing content: ' . $this->content );
     272
     273                while ( $this->cursor_position < mb_strlen( $this->content ) ) {
     274                        $char = mb_substr( $this->content, $this->cursor_position, 1 );
     275
     276                        $this->debug( 'In position ' . $this->cursor_position . ' with state ' . $this->state . ', looking at character "' . $char . '"' );
     277
     278                        $found_escape_character = false;
     279
     280                        switch ( $this->state ) {
     281                                case self::SHORTCODE_PARSE_STATE_DEFAULT:
     282                                case self::SHORTCODE_PARSE_STATE_IN_CONTENT:
     283                                        if (
     284                                                   ! $is_escaped
     285                                                && '[' === $char
     286                                                && preg_match( $registered_shortcode_regex, mb_substr( $this->content, $this->cursor_position ), $m ) ) {
     287                                                if ( $this->current_shortcode ) {
     288                                                        $this->stack[] = $this->current_shortcode;
     289                                                }
     290
     291                                                // We have found the beginning of a shortcode.
     292                                                $this->current_shortcode = array(
     293                                                        'full_tag' => $m[0],
     294                                                        'extra_opening_bracket' => $m['extra_opening_bracket'],
     295                                                        'tag_slug' => $m['tag_slug'],
     296                                                        'atts_and_values' => '',
     297                                                        'self_closing_slash' => '',
     298                                                        'inner_content' => '',
     299                                                        'extra_closing_bracket' => '',
     300                                                        'cursor_position' => $this->cursor_position,
     301                                                );
     302
     303                                                $this->cursor_position += mb_strlen( $m[0] );
     304
     305                                                $this->debug( 'Found "' . $m[0] . '", moving to position ' . $this->cursor_position );
     306                                                $this->debug( $this->current_shortcode );
     307
     308                                                // Move back one so it's as if we just processed the last character of the shortcode slug.
     309                                                $this->cursor_position--;
     310
     311                                                $this->state = self::SHORTCODE_PARSE_STATE_IN_TAG;
     312                                        } else {
     313                                                if ( self::SHORTCODE_PARSE_STATE_IN_CONTENT === $this->state ) {
     314                                                        $this->current_shortcode['full_tag'] .= $char;
     315                                                }
     316
     317                                                if ( ! $is_escaped && '\\' === $char ) {
     318                                                        // The next character is escaped.
     319                                                        $found_escape_character = true;
     320
     321                                                        $this->current_shortcode['inner_content'] .= $char;
     322                                                } elseif ( $is_escaped ) {
     323                                                        $this->current_shortcode['inner_content'] .= $char;
     324                                                } elseif ( self::SHORTCODE_PARSE_STATE_IN_CONTENT === $this->state && '[' === $char ) {
     325                                                        // Check whether it's a closing tag of any currently open shortcode.
     326                                                        $rest_of_closing_tag = '/' . $this->current_shortcode['tag_slug'] . ']';
     327
     328                                                        if ( $rest_of_closing_tag === mb_substr( $this->content, $this->cursor_position + 1, mb_strlen( $rest_of_closing_tag ) ) ) {
     329                                                                // The end of this shortcode.
     330
     331                                                                $this->current_shortcode['full_tag'] .= $rest_of_closing_tag;
     332
     333                                                                // Move the cursor to the end of the closing tag.
     334                                                                $this->cursor_position += mb_strlen( $rest_of_closing_tag );
     335
     336                                                                if ( $this->current_shortcode['extra_opening_bracket'] ) {
     337                                                                        if ( ']' === mb_substr( $this->content, $this->cursor_position + 1, 1 ) ) {
     338                                                                                $this->current_shortcode['full_tag'] .= ']';
     339                                                                                $this->current_shortcode['extra_closing_bracket'] = ']';
     340                                                                                $this->cursor_position++;
     341                                                                        } else {
     342                                                                                // If there was an extra opening bracket but not an extra closing bracket,
     343                                                                                // ignore the extra opening bracket.
     344
     345                                                                                $this->current_shortcode['full_tag'] = mb_substr( $this->current_shortcode['full_tag'], 1 );
     346                                                                                $this->current_shortcode['extra_opening_bracket'] = '';
     347
     348                                                                                // We initially thought it had an extra opening bracket, but it doesn't,
     349                                                                                // so it started one character later than we thought.
     350                                                                                $this->current_shortcode['cursor_position'] += 1;
     351                                                                        }
     352                                                                }
     353
     354                                                                $this->process_current_shortcode();
     355                                                        } else {
     356                                                                $this->debug( 'The closing tag was not for the currently open shortcode.' );
     357
     358                                                                $found_matching_shortcode = false;
     359
     360                                                                for ( $stack_index = count( $this->stack ) - 1; $stack_index >= 0; $stack_index-- ) {
     361                                                                        $rest_of_closing_tag = '/' . $this->stack[ $stack_index ]['tag_slug'] . ']';
     362
     363                                                                        if ( $rest_of_closing_tag === mb_substr( $this->content, $this->cursor_position + 1, mb_strlen( $rest_of_closing_tag ) ) ) {
     364                                                                                // Yes, it closes this one.
     365                                                                                $found_matching_shortcode = true;
     366
     367                                                                                if ( self::SHORTCODE_PARSE_STATE_IN_CONTENT === $this->state ) {
     368                                                                                        // We already saved the bracket as part of the full tag, expecting that the closing tag would be for the current shortcode.
     369                                                                                        // It's not, so remove it.
     370                                                                                        $this->current_shortcode['full_tag'] = mb_substr( $this->current_shortcode['full_tag'], 0, -1 );
     371                                                                                }
     372
     373                                                                                $this->debug( 'The closing tag was for this shortcode:', $this->stack[ $stack_index ] );
     374
     375                                                                                // This means that the "current" shortcode and any others above this one on the stack need to be closed out, because they are self-closing.
     376                                                                                do {
     377                                                                                        $this->debug( 'Inner content was:', $this->current_shortcode['inner_content'], 'Full tag was:', $this->current_shortcode['full_tag'] );
     378
     379                                                                                        $this->current_shortcode['full_tag'] = mb_substr( $this->current_shortcode['full_tag'], 0, -1 * mb_strlen( $this->current_shortcode['inner_content'] ) );
     380
     381                                                                                        // And there is no inner content.
     382                                                                                        $this->current_shortcode['inner_content'] = '';
     383
     384                                                                                        $this->process_current_shortcode(); // This sets $current_shortcode using the top stack item, so we don't need to do it.
     385                                                                                } while ( count( $this->stack ) > $stack_index + 1 );
     386
     387                                                                                // At this point, the shortcode that is being closed right now is $this->current_shortcode.
     388                                                                                // The easiest way to process this without duplicating code is to reprocess the current
     389                                                                                // character with the new stack and current shortcode, so the section above will get
     390                                                                                // triggered, since the closing tag will be for the current shortcode.
     391
     392                                                                                $this->debug( 'Restarting this iteration of the parsing loop with new stack structure.' );
     393                                                                                continue 3;
     394                                                                        }
     395                                                                }
     396
     397
     398                                                                if ( ! $found_matching_shortcode ) {
     399                                                                        $this->current_shortcode['inner_content'] .= $char;
     400                                                                }
     401                                                        }
     402                                                } elseif ( self::SHORTCODE_PARSE_STATE_IN_CONTENT === $this->state ) {
     403                                                        $this->current_shortcode['inner_content'] .= $char;
     404                                                }
     405                                        }
     406
     407                                        break;
     408                                case self::SHORTCODE_PARSE_STATE_IN_TAG:
     409                                        $this->current_shortcode['full_tag'] .= $char;
     410
     411                                        if ( ! $is_escaped && '/' === $char && mb_substr( $this->content, $this->cursor_position + 1, 1 ) === ']' ) {
     412                                                // The shortcode is over.
     413                                                $this->current_shortcode['self_closing_slash'] = '/';
     414                                                $this->current_shortcode['full_tag'] .= ']';
     415                                                $this->cursor_position++;
     416
     417                                                // If the shortcode had an extra opening bracket but doesn't have an extra
     418                                                // closing bracket, ignore the extra opening bracket.
     419
     420                                                if ( $this->current_shortcode['extra_opening_bracket'] ) {
     421                                                        if ( ']' === mb_substr( $this->content, $this->cursor_position + 1, 1 ) ) {
     422                                                                $this->current_shortcode['extra_closing_bracket'] = ']';
     423                                                                $this->current_shortcode['full_tag'] .= ']';
     424                                                                $this->cursor_position++;
     425                                                        } else {
     426                                                                $this->current_shortcode['full_tag'] = mb_substr( $this->current_shortcode['full_tag'], 1 );
     427                                                                $this->current_shortcode['extra_opening_bracket'] = '';
     428
     429                                                                // We initially thought it had an extra opening bracket, but it doesn't,
     430                                                                // so it started one character later than we thought.
     431                                                                $this->current_shortcode['cursor_position'] += 1;
     432                                                        }
     433                                                }
     434
     435                                                $this->process_current_shortcode();
     436
     437                                                break;
     438                                        } elseif ( ! $is_escaped && ']' === $char ) {
     439                                                if ( $this->current_shortcode['extra_opening_bracket'] ) {
     440                                                        // This makes the assumption that this shortcode is closed as soon as the double brackets are found:
     441                                                        //
     442                                                        // [[my-shortcode]][/my-shortcode]]
     443                                                        //
     444                                                        // But in theory, this could just be a shortcode with the content "]".
     445
     446                                                        if ( ']' === mb_substr( $this->content, $this->cursor_position + 1, 1 ) ) {
     447                                                                $this->current_shortcode['extra_closing_bracket'] = ']';
     448                                                                $this->current_shortcode['full_tag'] .= ']';
     449                                                                $this->cursor_position++;
     450
     451                                                                $this->process_current_shortcode();
     452                                                                break;
     453                                                        } else {
     454                                                                // There was not an extra closing bracket.
     455                                                                $this->debug( 'Extra closing bracket not found; the character was ' . mb_substr( $this->content, $this->cursor_position + 1, 1 ) );
     456                                                        }
     457                                                }
     458
     459                                                if ( false === mb_strpos( mb_substr( $this->content, $this->cursor_position ), '[/' . $this->current_shortcode['tag_slug'] . ']' ) ) {
     460                                                        // If there's no closing tag, it's a self-enclosed shortcode, and we're done with it.
     461                                                        $this->process_current_shortcode();
     462                                                } else {
     463                                                        $this->debug( 'Expecting to find a closing tag for ' . $this->current_shortcode['tag_slug'] );
     464                                                        $this->state = self::SHORTCODE_PARSE_STATE_IN_CONTENT;
     465                                                }
     466                                        } else {
     467                                                $this->current_shortcode['atts_and_values'] .= $char;
     468
     469                                                if ( ! $is_escaped && '\\' === $char ) {
     470                                                        $found_escape_character = true;
     471                                                } elseif ( ! $is_escaped && ( '"' === $char || "'" === $char ) ) {
     472                                                        $this->state = self::SHORTCODE_PARSE_STATE_IN_QUOTED_STRING;
     473                                                        $delimiter = $char;
     474                                                } else {
     475                                                        // Nothing to do.
     476                                                }
     477                                        }
     478
     479                                        break;
     480                                case self::SHORTCODE_PARSE_STATE_IN_QUOTED_STRING:
     481                                        $this->current_shortcode['full_tag'] .= $char;
     482                                        $this->current_shortcode['atts_and_values'] .= $char;
     483
     484                                        if ( $is_escaped ) {
     485                                                // Nothing to do. This is just an escaped character to be taken literally.
     486                                        } else {
     487                                                // Not escaped.
     488                                                if ( '\\' === $char ) {
     489                                                        // The next character is escaped.
     490                                                        $found_escape_character = true;
     491                                                } elseif ( $char === $delimiter ) {
     492                                                        $this->state = self::SHORTCODE_PARSE_STATE_IN_TAG;
     493                                                        $delimiter = null;
     494                                                }
     495                                        }
     496
     497                                        break;
     498                        }
     499
     500                        // Is the next character escaped?
     501                        if ( $found_escape_character ) {
     502                                $is_escaped = true;
     503                        } else {
     504                                // If we didn't find an escape character here, then no.
     505                                $is_escaped = false;
     506                        }
     507
     508                        $this->cursor_position++;
     509
     510                        $this->debug( 'Cursor position is ' . $this->cursor_position . '; strlen is ' . mb_strlen( $this->content ) );
     511                }
     512
     513                if ( self::SHORTCODE_PARSE_STATE_IN_QUOTED_STRING === $this->state ) {
     514                        // example: This is my content [footag foo=" [bartag]
     515                        // Should it be reprocessed in order to convert [bartag] or is this considered malformed?
     516                }
     517
     518                if ( self::SHORTCODE_PARSE_STATE_IN_TAG === $this->state ) {
     519                        // example: This is my content [footag foo="abc" bar="def" [bartag]
     520                        // Should it be reprocessed in order to convert [bartag] or is this considered malformed?
     521                }
     522
     523                if ( $this->current_shortcode ) {
     524                        $this->debug( 'There are still pending shortcodes to process.', $this->current_shortcode, $this->stack );
     525
     526                        /*
     527                         * If we end with shortcodes still on the stack, then there was a situation like this:
     528                         *
     529                         * [footag] [bartag] [baztag] [footag]content[/footag]
     530                         *
     531                         * i.e., a scenario where the parser was unsure whether the first [footag] was self-closing or not.
     532                         *
     533                         * By this point, $content will be in this format:
     534                         *
     535                         * [footag] bartag-output baztag-output footag-content-output
     536                         *
     537                         * so we need to back up and process the still-stored shortcodes as unclosed.
     538                         *
     539                         * An extreme version of this would look like:
     540                         *
     541                         * [footag] [footag] [footag] [footag] [footag] [footag] [footag] [footag] ... [footag][/footag]
     542                         *
     543                         * where the last tag would be the only one processed normally above and there would be n-1 [footag]s still on the stack.
     544                         */
     545                        while ( $this->current_shortcode ) {
     546                                // What we thought was part of this tag was just regular content.
     547                                $this->current_shortcode['full_tag'] = mb_substr( $this->current_shortcode['full_tag'], 0, -1 * mb_strlen( $this->current_shortcode['inner_content'] ) );
     548
     549                                // And there is no inner content.
     550                                $this->current_shortcode['inner_content'] = '';
     551
     552                                $this->process_current_shortcode(); // This sets $current_shortcode, so we don't need to do it.
     553                        }
     554                }
     555
     556                return $this->content;
     557        }
     558
     559        /**
     560         * Create an argument to pass to do_shortcode_tag. The format of this argument was determined
     561         * by the capture groups of the regular expression that used to be used to parse shortcodes out of content.
     562         *
     563         * @param array $shortcode An associative array comprising data about a shortcode in the text.
     564         * @return array A numerically-indexed array of the shortcode data ready for do_shortcode_tag().
     565         */
     566        private function shortcode_argument( $shortcode ) {
     567                return array(
     568                        $shortcode['full_tag'],
     569                        $shortcode['extra_opening_bracket'],
     570                        $shortcode['tag_slug'],
     571                        $shortcode['atts_and_values'],
     572                        $shortcode['self_closing_slash'],
     573                        $shortcode['inner_content'],
     574                        $shortcode['extra_closing_bracket'],
     575                );
     576        }
     577
     578        /**
     579         * The shortcode at the top of the stack is complete and can be processed.
     580         * Process it and modify the enclosing shortcode as if the content was passed in
     581         * with this shortcode already converted into HTML.
     582         */
     583        private function process_current_shortcode() {
     584                $this->debug( 'Content is: ' . $this->content );
     585
     586                $this->debug( $this->current_shortcode );
     587
     588                $argument_for_do_shortcode_tag = $this->shortcode_argument( $this->current_shortcode );
     589
     590                $shortcode_output = do_shortcode_tag( $argument_for_do_shortcode_tag );
     591
     592                // Replace based on position rather than find and replace, since this content is possible:
     593                //
     594                // Test 123 [some-shortcode] To use my shortcode, type [[some-shortcode]].
     595                $this->content =
     596                          mb_substr( $this->content, 0, $this->current_shortcode['cursor_position'] )
     597                        . $shortcode_output
     598                        . mb_substr( $this->content, $this->current_shortcode['cursor_position'] + mb_strlen( $this->current_shortcode['full_tag'] ) )
     599                        ;
     600
     601                // Update the cursor position to the end of this shortcode's output.
     602                // The -1 is because the position is incremented after this gets called to move it to the next character.
     603                $this->cursor_position = $this->current_shortcode['cursor_position'] + mb_strlen( $shortcode_output ) - 1;
     604
     605                // For any enclosing shortcode, its inner content needs to include the full output of this shortcode.
     606                if ( ! empty( $this->stack ) ) {
     607                        $this->current_shortcode = array_pop( $this->stack );
     608
     609                        $this->current_shortcode['inner_content'] .= $shortcode_output;
     610                        $this->current_shortcode['full_tag'] .= $shortcode_output;
     611
     612                        $this->state = self::SHORTCODE_PARSE_STATE_IN_CONTENT;
     613                } else {
     614                        $this->current_shortcode = null;
     615
     616                        $this->state = self::SHORTCODE_PARSE_STATE_DEFAULT;
     617
     618                        // In the default state, we can skip over any content that couldn't be a shortcode,
     619                        // so let's move forward near the next bracket.
     620                        $this->forward_cursor_to_next_bracket();
     621                }
     622
     623                $this->debug( 'Content is: ' . $this->content );
     624        }
     625
     626        private function forward_cursor_to_next_bracket() {
     627                /*
     628                 * The max() here is because $cursor_position can be -1 if a shortcode
     629                 * at the beginning of the content didn't have any output and reset the
     630                 * cursor back to the beginning. It's -1 instead of zero because it will
     631                 * be incremented later in the loop to set it to zero for the next iteration.
     632                 */
     633                $next_bracket_location = mb_strpos( $this->content, '[', max( 0, $this->cursor_position ) );
     634
     635                if ( false !== $next_bracket_location ) {
     636                        $this->debug( 'Current cursor position: ' . $this->cursor_position );
     637
     638                        /*
     639                         * Again, the -1 is because this will be incremented before it is used,
     640                         * and we really want it to have a minimum value of zero.
     641                         */
     642                        $this->cursor_position = max( -1, $next_bracket_location - 2 );
     643
     644                        $this->debug( 'Jumped ahead to position ' . $this->cursor_position );
     645                }
     646        }
     647
     648        /**
     649         * Outputs debug data.  Useful when running unit tests to see how content is being parsed.
     650         *
     651         * @param mixed One of more variables of any type.
     652         */
     653        private function debug( /* ... */ ) {
     654                if ( defined( 'WP_DEBUG' ) && WP_DEBUG && $this->DEBUG ) {
     655                        foreach ( func_get_args() as $arg ) {
     656                                if ( 'string' === gettype( $arg ) ) {
     657                                        error_log( 'Shortcode_Parser debug: ' . $arg );
     658                                } else {
     659                                        error_log( 'Shortcode_Parser debug: ' . var_export( $arg, true ) );
     660                                }
     661                        }
     662                }
     663        }
     664
     665}
     666
     667/**
    227668 * Retrieve the shortcode regular expression for searching.
    228669 *
    229670 * The regular expression combines the shortcode tags in the regular expression
  • tests/phpunit/tests/shortcode.php

     
    972972                );
    973973                $this->assertEquals( 'test-shortcode-tag', $this->tagname );
    974974        }
    975 }
     975       
     976        function test_bracket_in_shortcode_attribute() {
     977                do_shortcode( '[test-shortcode-tag subject="[This is my subject]" /]' );
     978                $expected_attrs = array(
     979                        "subject" => "[This is my subject]",
     980                );
     981                $this->assertEquals( $expected_attrs, $this->atts );
     982        }
     983       
     984        function test_self_closing_shortcode_with_quoted_end_tag() {
     985                $out = do_shortcode( '[test-shortcode-tag]Test 123[footag foo="[/test-shortcode-tag]"/] [baztag]bazcontent[/baztag]' );
     986               
     987                $this->assertEquals( 'Test 123foo = [/test-shortcode-tag] content = bazcontent', $out );
     988        }
     989       
     990        function test_nested_shortcodes() {
     991                /*
     992                do_shortcode( '[test-shortcode-tag]Some content [footag foo="foo content"/] some other content[/test-shortcode-tag]' );
     993               
     994                $this->assertEquals( 'Some content foo = foo content some other content', $this->content );
     995
     996                $out = do_shortcode( '[footag foo="1"][footag foo="2"][footag foo="3"][footag foo="4"][/footag][footag foo="4a"][/footag][/footag][/footag][/footag]' );
     997               
     998                $this->assertEquals( 'foo = 1', $out );
     999                */
     1000                $out = do_shortcode( '[footag foo="1"] abc [bartag foo="2"] def [/footag] something else [test-shortcode-tag attr="[/footag]" attr2="[/bartag]"][/test-shortcode-tag]' );
     1001               
     1002                $this->assertEquals( 'foo = 1something else ', $out );
     1003        }
     1004       
     1005        /**
     1006         * @ticket 49955
     1007         */
     1008        function test_ticket_49955() {
     1009                add_shortcode( 'ucase', function ( $atts, $content ) {
     1010                        return strtoupper( $content );
     1011                } );
     1012                       
     1013                $out = do_shortcode( 'This [[ucase]] shortcode [ucase]demonstrates[/ucase] the usage of enclosing shortcodes.' );
     1014               
     1015                $this->assertEquals( 'This [ucase] shortcode DEMONSTRATES the usage of enclosing shortcodes.', $out );
     1016        }
     1017       
     1018                /**
     1019         * @ticket 43725
     1020         */
     1021        public function test_same_tag_multiple_formats_open_closed_one() {
     1022                $in = <<<EOT
     1023This post uses URL multiple times.
     1024
     1025[url]Now this is wrapped[/url]
     1026
     1027[url] This one is standalone
     1028
     1029[url]Now this is wrapped too[/url]
     1030EOT;
     1031                $expected = <<<EOT
     1032This post uses URL multiple times.
     1033
     1034http://www.wordpress.org/
     1035
     1036http://www.wordpress.org/ This one is standalone
     1037
     1038http://www.wordpress.org/
     1039EOT;
     1040                $out      = do_shortcode( $in );
     1041                $this->assertEquals( strip_ws( $expected ), strip_ws( $out ) );
     1042        }
     1043
     1044        /**
     1045         * @ticket 43725
     1046         */
     1047        public function test_same_tag_multiple_formats_open_closed_two() {
     1048                $in = <<<EOT
     1049This post uses URL multiple times.
     1050
     1051[url]Now this is wrapped[/url]
     1052
     1053[url/] This one is standalone
     1054
     1055[url]Now this is wrapped too[/url]
     1056EOT;
     1057                $expected = <<<EOT
     1058This post uses URL multiple times.
     1059
     1060http://www.wordpress.org/
     1061
     1062http://www.wordpress.org/ This one is standalone
     1063
     1064http://www.wordpress.org/
     1065EOT;
     1066                $out      = do_shortcode( $in );
     1067                $this->assertEquals( strip_ws( $expected ), strip_ws( $out ) );
     1068        }
     1069}
     1070 No newline at end of file