WordPress.org

Make WordPress Core

Ticket #37693: 37693.11.patch

File 37693.11.patch, 5.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 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                                var before = string.charAt( startOffset - 1 );
     124                                var after = string.charAt( startOffset + 1 );
     125
     126                                // test*test* => pass
     127                                // test *test* => pass
     128                                // test* test => fail
     129                                if ( startOffset && /\S/.test( before ) ) {
     130                                        if ( /\s/.test( after ) || before === delimiterFirstChar ) {
     131                                                return;
     132                                        }
     133                                }
     134
     135                                // Do not replace when only whitespace and delimiter characters.
     136                                if ( ( new RegExp( '^[\\s' + escapeRegExp( delimiterFirstChar ) + ']+$' ) ).test( string.slice( startOffset, endOffset ) ) ) {
    120137                                        return;
    121138                                }
    122139
    123                                 startOffset = match.index;
    124                                 endOffset = offset - p.end.length;
    125140                                pattern = p;
    126141
    127142                                return false;
     
    142157                                        node = node.splitText( startOffset );
    143158                                        zero = node.splitText( offset - startOffset );
    144159
    145                                         node.deleteData( 0, pattern.start.length );
    146                                         node.deleteData( node.data.length - pattern.end.length, pattern.end.length );
     160                                        node.deleteData( 0, pattern.delimiter.length );
     161                                        node.deleteData( node.data.length - pattern.delimiter.length, pattern.delimiter.length );
    147162
    148163                                        editor.formatter.apply( pattern.format, {}, node );
    149164
  • 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 within text.', 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
     329        QUnit.test( 'Inline: disallow \\S-delimiter-\\s.', function( assert ) {
     330                type( 'a` a`', function() {
     331                        assert.equal( editor.getContent(), '<p>a` a`</p>' );
     332                        assert.equal( editor.selection.getRng().startOffset, 5 );
     333                }, assert.async() );
     334        } );
     335
     336        QUnit.test( 'Inline: allow \\s-delimiter-\\s.', function( assert ) {
     337                type( 'a ` a`', function() {
     338                        assert.equal( editor.getContent(), '<p>a <code> a</code></p>' );
     339                        assert.equal( editor.selection.getRng().startOffset, 1 );
     340                }, assert.async() );
     341        } );
     342
     343        QUnit.test( 'Inline: allow \\S-delimiter-\\S.', function( assert ) {
     344                type( 'a`a`', function() {
     345                        assert.equal( editor.getContent(), '<p>a<code>a</code></p>' );
     346                        assert.equal( editor.selection.getRng().startOffset, 1 );
     347                }, assert.async() );
     348        } );
     349
    322350        QUnit.test( 'Inline: after typing.', function( assert ) {
    323351                editor.setContent( '<p>test test test</p>' );
    324352                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 5 );
     
    337365                }, assert.async() );
    338366        } );
    339367
    340         QUnit.test( 'Convert with previously unconverted pattern', function( assert ) {
     368        QUnit.test( 'Convert with previously unconverted pattern.', function( assert ) {
    341369                editor.setContent( '<p>`test` test&nbsp;</p>' );
    342370                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 12 );
    343371