WordPress.org

Make WordPress Core

Ticket #37693: 37693.9.patch

File 37693.9.patch, 4.0 KB (added by iseulde, 3 years ago)
  • src/wp-includes/js/tinymce/plugins/wptextpattern/plugin.js

     
    4646                ];
    4747
    4848                var inlinePatterns = settings.inline || [
    49                         { start: '`', end: '`', format: 'code' }
     49                        { delimiter: '`', format: 'code' }
    5050                ];
    5151
    5252                var canUndo;
    5353                var chars = [];
    5454
    5555                tinymce.each( inlinePatterns, function( pattern ) {
    56                         tinymce.each( ( pattern.start + pattern.end ).split( '' ), function( c ) {
    57                                 if ( tinymce.inArray( chars, c ) === -1 ) {
    58                                         chars.push( c );
    59                                 }
    60                         } );
     56                        var c = pattern.delimiter.slice( -1 );
     57
     58                        if ( tinymce.inArray( chars, c ) === -1 ) {
     59                                chars.push( c );
     60                        }
    6161                } );
    6262
    6363                editor.on( 'selectionchange', function() {
     
    108108                        var string = node.data.slice( 0, offset );
    109109
    110110                        tinymce.each( inlinePatterns, function( p ) {
    111                                 var regExp = new RegExp( escapeRegExp( p.start ) + '\\S+' + escapeRegExp( p.end ) + '$' );
     111                                var regExp = new RegExp( '(.*)' + escapeRegExp( p.delimiter ) + '.+' + escapeRegExp( p.delimiter ) + '$' );
    112112                                var match = string.match( regExp );
    113113
    114114                                if ( ! match ) {
    115115                                        return;
    116116                                }
    117117
    118                                 // Don't allow pattern characters in the text.
    119                                 if ( node.data.slice( match.index + p.start.length, offset - p.end.length ).indexOf( p.start.slice( 0, 1 ) ) !== -1 ) {
     118                                startOffset = match.index + match[1].length;
     119                                endOffset = offset - p.delimiter.length;
     120
     121                                // Do not allow whitespace and delimiter characters from start to end.
     122                                if ( ( new RegExp( '^[\\s' + escapeRegExp( p.delimiter.slice( 0, 1 ) ) + ']+$' ) ).test( string.slice( startOffset + 1, endOffset ) ) ) {
     123                                        return;
     124                                }
     125
     126                                // Do not allow more delimiter characters in front.
     127                                if ( startOffset && ( new RegExp( escapeRegExp( p.delimiter.slice( 0, 1 ) ) ) ).test( node.data.charAt( startOffset - 1 ) ) ) {
    120128                                        return;
    121129                                }
    122130
    123                                 startOffset = match.index;
    124                                 endOffset = offset - p.end.length;
    125131                                pattern = p;
    126132
    127133                                return false;
     
    142148                                        node = node.splitText( startOffset );
    143149                                        zero = node.splitText( offset - startOffset );
    144150
    145                                         node.deleteData( 0, pattern.start.length );
    146                                         node.deleteData( node.data.length - pattern.end.length, pattern.end.length );
     151                                        node.deleteData( 0, pattern.delimiter.length );
     152                                        node.deleteData( node.data.length - pattern.delimiter.length, pattern.delimiter.length );
    147153
    148154                                        editor.formatter.apply( pattern.format, {}, node );
    149155
  • tests/qunit/wp-includes/js/tinymce/plugins/wptextpattern/plugin.js

     
    157157                                        plugins: 'wptextpattern',
    158158                                        wptextpattern: {
    159159                                                inline: [
    160                                                         { start: '`', end: '`', format: 'code' },
    161                                                         { start: '``', end: '``', format: 'bold' }
     160                                                        { delimiter: '`', format: 'code' },
     161                                                        { delimiter: '``', format: 'bold' }
    162162                                                ]
    163163                                        },
    164164                                        init_instance_callback: function() {
     
    319319                }, assert.async() );
    320320        } );
    321321
     322        QUnit.test( 'Inline: allow spaces', function( assert ) {
     323                type( '`a a`', function() {
     324                        assert.equal( editor.getContent(), '<p><code>a a</code></p>' );
     325                        assert.equal( editor.selection.getRng().startOffset, 1 );
     326                }, assert.async() );
     327        } );
     328
    322329        QUnit.test( 'Inline: after typing.', function( assert ) {
    323330                editor.setContent( '<p>test test test</p>' );
    324331                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 5 );
     
    341348                editor.setContent( '<p>`test` test&nbsp;</p>' );
    342349                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 12 );
    343350
    344                 type( '`test`', function() {
     351                type( '`\btest`', function() {
    345352                        assert.equal( editor.getContent(), '<p>`test` test&nbsp;<code>test</code></p>' );
    346353                }, assert.async() );
    347354        } );