WordPress.org

Make WordPress Core

Ticket #36585: 36585.3.diff

File 36585.3.diff, 6.5 KB (added by jnylen0, 4 years ago)

Issues with some tests in Firefox (though the actual functionality seems fine)

  • src/wp-includes/js/tinymce/plugins/wptextpattern/plugin.js

     
    3939
    4040                var canUndo;
    4141                var chars = [];
     42                var contentChangeCallback = null;
    4243
    4344                tinymce.each( inlinePatterns, function( pattern ) {
    4445                        tinymce.each( ( pattern.start + pattern.end ).split( '' ), function( c ) {
     
    4849                        } );
    4950                } );
    5051
    51                 editor.on( 'selectionchange', function() {
    52                         canUndo = null;
    53                 } );
    54 
    5552                editor.on( 'keydown', function( event ) {
    5653                        if ( ( canUndo && event.keyCode === 27 /* ESCAPE */ ) || ( canUndo === 'space' && event.keyCode === VK.BACKSPACE ) ) {
    5754                                editor.undoManager.undo();
     
    6259                        if ( event.keyCode === VK.ENTER && ! VK.modifierPressed( event ) ) {
    6360                                enter();
    6461                        }
    65                 }, true );
    6662
    67                 editor.on( 'keyup', function( event ) {
     63                        function queueContentChangeCallback( callback ) {
     64                                if ( 'onselectionchange' in editor.getDoc() ) {
     65                                        contentChangeCallback = callback;
     66                                } else {
     67                                        // Gecko doesn't support the 'selectionchange' event
     68                                        setTimeout( callback, 0 );
     69                                }
     70                        }
     71
     72                        // We need to execute space() and inline() after 'keydown' because
     73                        // they depend on the editor content being updated with the keypress in
     74                        // question, and before 'keyup' because other keys may be pressed
     75                        // before then.  So queue the callback and execute it during the
     76                        // 'selectionchange' event that immediately follows the keypress.
    6877                        if ( event.keyCode === VK.SPACEBAR && ! event.ctrlKey && ! event.metaKey && ! event.altKey ) {
    69                                 space();
     78                                queueContentChangeCallback( space );
    7079                        } else if ( event.keyCode > 47 && ! ( event.keyCode >= 91 && event.keyCode <= 93 ) ) {
    71                                 inline();
     80                                queueContentChangeCallback( inline );
    7281                        }
     82                }, true );
     83
     84                editor.on( 'selectionchange', function( event ) {
     85                        canUndo = null;
     86                        if ( contentChangeCallback ) {
     87                                contentChangeCallback();
     88                                contentChangeCallback = null;
     89                        }
    7390                } );
    7491
    7592                function inline() {
  • tests/qunit/wp-includes/js/tinymce/plugins/wptextpattern/plugin.js

     
    66                return;
    77        }
    88
    9         function mceType(chr) {
    10                 var editor = tinymce.activeEditor, keyCode, charCode, evt, startElm, rng, startContainer, startOffset, textNode;
     9        function mceType( chr, eventType ) {
     10                var editor = tinymce.activeEditor,
     11                        doKeyDown  = ! eventType || /\bkeydown\b/.test( eventType ),
     12                        doKeyPress = ! eventType || /\bkeypress\b/.test( eventType ),
     13                        doKeyUp    = ! eventType || /\bkeyup\b/.test( eventType ),
     14                        keyCode, charCode, evt,
     15                        startElm, rng, startContainer, startOffset,
     16                        textNode;
    1117
    1218                function charCodeToKeyCode(charCode) {
    1319                        var lookup = {
     
    5662                evt = evt || {keyCode: keyCode, charCode: charCode};
    5763
    5864                startElm = editor.selection.getStart();
    59                 fakeEvent(startElm, 'keydown', evt);
    60                 fakeEvent(startElm, 'keypress', evt);
     65                if ( doKeyDown ) {
     66                        fakeEvent( startElm, 'keydown', evt );
     67                }
     68                if ( doKeyPress ) {
     69                        fakeEvent( startElm, 'keypress', evt );
     70                }
    6171
    62                 if (!evt.isDefaultPrevented()) {
     72                if ( ( doKeyDown || doKeyPress ) && ! evt.isDefaultPrevented() ) {
    6373                        if (keyCode === 8) {
    6474                                if (editor.getDoc().selection) {
    6575                                        rng = editor.getDoc().selection.createRange();
     
    107117                                rng.collapse(true);
    108118                                editor.selection.setRng(rng);
    109119                        }
     120                        editor.fire( 'selectionchange' );
    110121                }
    111122
    112                 fakeEvent(startElm, 'keyup', evt);
     123                if ( doKeyUp ) {
     124                        fakeEvent( startElm, 'keyup', evt );
     125                }
    113126        }
    114127
    115128        function type() {
     
    219232                }, assert.async() );
    220233        } );
    221234
    222         QUnit.test( 'Only transform when at the cursor is at the start.', function( assert ) {
     235        QUnit.test( 'Only transform when the cursor is at the start.', function( assert ) {
    223236                editor.setContent( '<p>* test</p>' );
    224237                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 6 );
    225238
     
    228241                }, assert.async() );
    229242        } );
    230243
     244        QUnit.test( 'Transform when space pressed along with another key. (1)', function( assert ) {
     245                var done = assert.async();
     246
     247                editor.setContent( '<p>*' );
     248                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 1 );
     249
     250                mceType( ' ', 'keydown,keypress' );
     251                mceType( 'a', 'keydown,keypress' );
     252                mceType( ' ', 'keyup' );
     253                mceType( 'a', 'keyup' );
     254
     255                setTimeout( function() {
     256                        assert.equal( editor.getContent(), '<ul>\n<li>a</li>\n</ul>' );
     257                        assert.equal( editor.selection.getRng().startOffset, 1 );
     258                        done();
     259                } );
     260        } );
     261
     262        QUnit.test( 'Transform when space pressed along with another key. (2)', function( assert ) {
     263                var done = assert.async();
     264
     265                editor.setContent( '<p>*' );
     266                editor.selection.setCursorLocation( editor.$( 'p' )[0].firstChild, 1 );
     267
     268                mceType( ' ', 'keydown,keypress' );
     269                mceType( '0', 'keydown,keypress' );
     270                mceType( '0', 'keyup' );
     271                mceType( ' ', 'keyup' );
     272
     273                setTimeout( function() {
     274                        assert.equal( editor.getContent(), '<ul>\n<li>0</li>\n</ul>' );
     275                        assert.equal( editor.selection.getRng().startOffset, 1 );
     276                        done();
     277                } );
     278        } );
     279
    231280        QUnit.test( 'Backspace should undo the transformation.', function( assert ) {
    232281                editor.setContent( '<p>test</p>' );
    233282                editor.selection.setCursorLocation();
     
    309358                        assert.equal( editor.getContent(), '<p>test `````</p>' );
    310359                }, assert.async() );
    311360        } );
     361
     362        QUnit.test( 'Inline: backtick pressed along with another key. (1)', function( assert ) {
     363                type( '`abc', function() {
     364                        mceType( '`', 'keydown,keypress' );
     365                        mceType( 'a', 'keydown,keypress' );
     366                        mceType( '`', 'keyup' );
     367                        mceType( 'a', 'keyup' );
     368                }, function() {
     369                        assert.equal( editor.getContent(), '<p><code>abc</code>a</p>' );
     370                        assert.equal( editor.selection.getRng().startOffset, 2 );
     371                }, assert.async() );
     372        } );
     373
     374        QUnit.test( 'Inline: backtick pressed along with another key. (2)', function( assert ) {
     375                type( '`abc', function() {
     376                        mceType( '`', 'keydown,keypress' );
     377                        mceType( 'a', 'keydown,keypress' );
     378                        mceType( 'a', 'keyup' );
     379                        mceType( '`', 'keyup' );
     380                }, function() {
     381                        assert.equal( editor.getContent(), '<p><code>abc</code>a</p>' );
     382                        assert.equal( editor.selection.getRng().startOffset, 2 );
     383                }, assert.async() );
     384        } );
     385
    312386} )( window.jQuery, window.QUnit, window.tinymce, window.setTimeout );