WordPress.org

Make WordPress Core

Ticket #37693: 37693.10.patch

File 37693.10.patch, 3.7 KB (added by azaozz, 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 escDelimiter = escapeRegExp( p.delimiter );
     112                                var delimiterFirstChar = p.delimiter.charAt( 0 );
     113                                var regExp = new RegExp( '(.*)' + escDelimiter + '.+' + escDelimiter + '$' );
    112114                                var match = string.match( regExp );
    113115
    114116                                if ( ! match ) {
     
    115117                                        return;
    116118                                }
    117119
    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 ) {
     120                                startOffset = match[1].length;
     121                                endOffset = offset - p.delimiter.length;
     122
     123                                // Do not replace when no white space or start of line before the pattern.
     124                                if ( startOffset && ! /\s/.test( string.charAt( startOffset - 1 ) ) ) {
    120125                                        return;
    121126                                }
    122127
    123                                 startOffset = match.index;
    124                                 endOffset = offset - p.end.length;
     128                                // Do not replace when only whitespace and delimiter characters.
     129                                if ( ( new RegExp( '^[\\s' + escapeRegExp( delimiterFirstChar ) + ']+$' ) ).test( string.slice( startOffset, endOffset ) ) ) {
     130                                        return;
     131                                }
     132
    125133                                pattern = p;
    126134
    127135                                return false;
     
    142150                                        node = node.splitText( startOffset );
    143151                                        zero = node.splitText( offset - startOffset );
    144152
    145                                         node.deleteData( 0, pattern.start.length );
    146                                         node.deleteData( node.data.length - pattern.end.length, pattern.end.length );
     153                                        node.deleteData( 0, pattern.delimiter.length );
     154                                        node.deleteData( node.data.length - pattern.delimiter.length, pattern.delimiter.length );
    147155
    148156                                        editor.formatter.apply( pattern.format, {}, node );
    149157
  • 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 );