WordPress.org

Make WordPress Core

Ticket #37693: 37693.8.patch

File 37693.8.patch, 4.3 KB (added by iseulde, 4 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(
     112                                        // Optional and greedy to push match back to end
     113                                        '(.*)' +
     114                                        // Start delimiter
     115                                        escapeRegExp( p.delimiter ) +
     116                                        // Non whitespace, non delimiter character
     117                                        '[^\\s' + escapeRegExp( p.delimiter.slice( -1 ) ) + ']' +
     118                                        // Optional characters
     119                                        '.*' +
     120                                        // Optional non whitespace, non delimiter character
     121                                        '[^\\s' + escapeRegExp( p.delimiter.slice( 0, 1 ) ) + ']' +
     122                                        // End delimiter
     123                                        escapeRegExp( p.delimiter ) +
     124                                        // End of string
     125                                        '$'
     126                                );
     127
    112128                                var match = string.match( regExp );
    113129
    114130                                if ( ! match ) {
    115131                                        return;
    116132                                }
    117133
    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 ) {
     134                                startOffset = match.index + match[1].length;
     135                                endOffset = offset - p.delimiter.length;
     136
     137                                if ( startOffset && ( new RegExp( escapeRegExp( p.delimiter.slice( 0, 1 ) ) ) ).test( node.data.charAt( startOffset - 1 ) ) ) {
    120138                                        return;
    121139                                }
    122140
    123                                 startOffset = match.index;
    124                                 endOffset = offset - p.end.length;
    125141                                pattern = p;
    126142
    127143                                return false;
     
    142158                                        node = node.splitText( startOffset );
    143159                                        zero = node.splitText( offset - startOffset );
    144160
    145                                         node.deleteData( 0, pattern.start.length );
    146                                         node.deleteData( node.data.length - pattern.end.length, pattern.end.length );
     161                                        node.deleteData( 0, pattern.delimiter.length );
     162                                        node.deleteData( node.data.length - pattern.delimiter.length, pattern.delimiter.length );
    147163
    148164                                        editor.formatter.apply( pattern.format, {}, node );
    149165
  • 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
     329        QUnit.test( 'Inline: allow pattern characters', function( assert ) {
     330                type( '``a`a``', function() {
     331                        assert.equal( editor.getContent(), '<p><strong>a`a</strong></p>' );
     332                        assert.equal( editor.selection.getRng().startOffset, 1 );
     333                }, assert.async() );
     334        } );
     335
     336        QUnit.test( 'Inline: previous character should not be non space', function( assert ) {
     337                type( 'a`a`', function() {
     338                        assert.equal( editor.getContent(), '<p>a`a`</p>' );
     339                        assert.equal( editor.selection.getRng().startOffset, 4 );
     340                }, assert.async() );
     341        } );
     342
    322343        QUnit.test( 'Inline: after typing.', function( assert ) {
    323344                editor.setContent( '<p>test test test</p>' );
    324345                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 5 );