From 44715656cda2461cbfe3caec4378fc0bb711f53c Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Thu, 30 Dec 2021 18:33:27 +0100 Subject: [PATCH 01/44] WiP. --- .../src/documentlist/documentlistediting.js | 22 +++++++++++++++++++ .../src/documentlist/utils/model.js | 19 +++++++++------- 2 files changed, 33 insertions(+), 8 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index a9d0b144fc5..382028cc9ad 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -14,6 +14,7 @@ import { CKEditorError } from 'ckeditor5/src/utils'; import DocumentListIndentCommand from './documentlistindentcommand'; import DocumentListCommand from './documentlistcommand'; +import DocumentListMergeCommand from './documentlistmergecommand'; import { listItemDowncastConverter, listItemParagraphDowncastConverter, @@ -84,6 +85,27 @@ export default class DocumentListEditing extends Plugin { editor.commands.add( 'indentList', new DocumentListIndentCommand( editor, 'forward' ) ); editor.commands.add( 'outdentList', new DocumentListIndentCommand( editor, 'backward' ) ); + + editor.commands.add( 'mergeListItem', new DocumentListMergeCommand( editor ) ); + + // Backspace handling + // - Collapsed selection at the beginning of the first item of list + // -> outdent command + // - Collapsed selection at the beginning of the first block of an item + // - Item before is empty + // -> change indent to match previous + // -> standard delete command + // - Item before is not empty + // -> change indent to match previous + // -> merge block with previous item + // - Non-collapsed selection with first position in the first block of a list item and the last position in other item + // - first position in empty block + // -> change indent of the last block to match the first block + // -> standard delete command + // - first position in non-empty block + // -> change indent of the last block to match the first block + // -> standard delete command + // -> merge last block with the first block } /** diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 0891a635294..06ef0813f50 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -230,16 +230,17 @@ export function mergeListItemBefore( listBlock, parentBlock, writer ) { * @param {module:engine/model/writer~Writer} writer The model writer. * @param {Object} [options] * @param {Boolean} [options.expand=false] Whether should expand the list of blocks to include complete list items + * @param {Number} [options.indentBy=1] TODO * (all blocks of given list items). */ -export function indentBlocks( blocks, writer, { expand } = {} ) { +export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { blocks = toArray( blocks ); // Expand the selected blocks to contain the whole list items. const allBlocks = expand ? expandListBlocksToCompleteItems( blocks ) : blocks; for ( const block of allBlocks ) { - writer.setAttribute( 'listIndent', block.getAttribute( 'listIndent' ) + 1, block ); + writer.setAttribute( 'listIndent', block.getAttribute( 'listIndent' ) + indentBy, block ); } return allBlocks; @@ -352,7 +353,7 @@ export function isOnlyOneListItemSelected( blocks ) { * * @protected */ -export function outdentItemsAfterItemRemoved( lastBlock, writer ) { +export function outdentItemsAfterItemRemoved( lastBlock, writer, { baseIndent = 0 } = {} ) { const changedBlocks = []; // Start from the model item that is just after the last turned-off item. @@ -411,11 +412,11 @@ export function outdentItemsAfterItemRemoved( lastBlock, writer ) { const indent = node.getAttribute( 'listIndent' ); // If the indent is 0 we are not going to change anything anyway. - if ( indent == 0 ) { + if ( indent == baseIndent ) { break; } - // We check if that's item indent is lower as current relative indent. + // We check if that's item indent is lower than current relative indent. if ( indent < currentIndent ) { // If it is, current relative indent becomes that indent. currentIndent = indent; @@ -423,13 +424,15 @@ export function outdentItemsAfterItemRemoved( lastBlock, writer ) { // Fix indent relatively to current relative indent. // Note, that if we just changed the current relative indent, the newIndent will be equal to 0. - const newIndent = indent - currentIndent; + const newIndent = indent - currentIndent + baseIndent; // Save the entry in changes array. We do not apply it at the moment, because we will need to // reverse the changes so the last item is changed first. // This is to keep model in correct state all the time. - writer.setAttribute( 'listIndent', newIndent, node ); - changedBlocks.push( node ); + if ( node.getAttribute( 'listIndent' ) != newIndent ) { + writer.setAttribute( 'listIndent', newIndent, node ); + changedBlocks.push( node ); + } } return changedBlocks; From d2cded2181fe16c2027739bcee466f09bf6f3c17 Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Wed, 5 Jan 2022 14:48:57 +0100 Subject: [PATCH 02/44] Prototype of DocumentListMergeCommand. --- .../src/documentlist/documentlistediting.js | 60 ++++++--- .../documentlist/documentlistindentcommand.js | 4 +- .../documentlist/documentlistmergecommand.js | 122 ++++++++++++++++++ .../src/documentlist/utils/model.js | 13 +- 4 files changed, 177 insertions(+), 22 deletions(-) create mode 100644 packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 382028cc9ad..a56865fc90c 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -88,24 +88,48 @@ export default class DocumentListEditing extends Plugin { editor.commands.add( 'mergeListItem', new DocumentListMergeCommand( editor ) ); - // Backspace handling - // - Collapsed selection at the beginning of the first item of list - // -> outdent command - // - Collapsed selection at the beginning of the first block of an item - // - Item before is empty - // -> change indent to match previous - // -> standard delete command - // - Item before is not empty - // -> change indent to match previous - // -> merge block with previous item - // - Non-collapsed selection with first position in the first block of a list item and the last position in other item - // - first position in empty block - // -> change indent of the last block to match the first block - // -> standard delete command - // - first position in non-empty block - // -> change indent of the last block to match the first block - // -> standard delete command - // -> merge last block with the first block + this.listenTo( editor.editing.view.document, 'delete', ( evt, data ) => { + if ( data.direction !== 'backward' ) { + return; + } + + const mergeListCommand = editor.commands.get( 'mergeListItem' ); + + if ( mergeListCommand.isEnabled ) { + mergeListCommand.execute(); + + data.preventDefault(); + evt.stop(); + + return; + } + + const selection = editor.model.document.selection; + + if ( !selection.isCollapsed ) { + return; + } + + const firstPosition = selection.getFirstPosition(); + + if ( !firstPosition.isAtStart ) { + return; + } + + const positionParent = firstPosition.parent; + + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return; + } + + const previousIsAListItem = positionParent.previousSibling && positionParent.previousSibling.hasAttribute( 'listItemId' ); + + if ( previousIsAListItem ) { + return; + } + + this.editor.execute( 'outdentList' ); + }, { context: 'li' } ); } /** diff --git a/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js b/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js index a8ffe0b75f6..e7b21f25f09 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js @@ -13,7 +13,7 @@ import { indentBlocks, isFirstBlockOfListItem, isOnlyOneListItemSelected, - outdentBlocks, + outdentBlocksWithMerge, splitListItemBefore } from './utils/model'; import ListWalker from './utils/listwalker'; @@ -81,7 +81,7 @@ export default class DocumentListIndentCommand extends Command { // Now just update the attributes of blocks. const changedBlocks = this._direction == 'forward' ? indentBlocks( blocks, writer, { expand: true } ) : - outdentBlocks( blocks, writer, { expand: true } ); + outdentBlocksWithMerge( blocks, writer, { expand: true } ); this._fireAfterExecute( changedBlocks ); } diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js new file mode 100644 index 00000000000..81929be8501 --- /dev/null +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -0,0 +1,122 @@ +/** + * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license + */ + +/** + * @module list/documentlist/documentlistmergecommand + */ + +import { Command } from 'ckeditor5/src/core'; +import { + indentBlocks, + mergeListItemBefore +} from './utils/model'; + +/** + * TODO + * The document list indent command. It is used by the {@link module:list/documentlist~DocumentList list feature}. + * + * @extends module:core/command~Command + */ +export default class DocumentListMergeCommand extends Command { + /** + * @inheritDoc + */ + refresh() { + this.isEnabled = this._checkEnabled(); + } + + /** + * TODO + * + * @fires execute + * @fires afterExecute + */ + execute() { + const model = this.editor.model; + const selection = model.document.selection; + + // Backspace handling + // - Collapsed selection at the beginning of the first item of list + // -> outdent command + // - Collapsed selection at the beginning of the first block of an item + // - Item before is empty + // -> change indent to match previous (with sub lists) + // -> standard delete command + // - Item before is not empty + // -> change indent to match previous + // -> merge block with previous item + // - Non-collapsed selection with first position in the first block of a list item and the last position in other item + // - first position in empty block + // -> change indent of the last block to match the first block + // -> standard delete command + // - first position in non-empty block + // -> change indent of the last block to match the first block + // -> standard delete command + // -> merge last block with the first block + + model.change( writer => { + const firstPosition = selection.getFirstPosition(); + const firstPositionParent = firstPosition.parent; + const firstNode = selection.isCollapsed ? firstPositionParent.previousSibling : firstPositionParent; + const lastNode = selection.getLastPosition().parent; + + const firstIndent = firstNode.getAttribute( 'listIndent' ); + const lastIndent = lastNode.getAttribute( 'listIndent' ); + + if ( firstIndent != lastIndent ) { + indentBlocks( lastNode, writer, { expand: true, indentBy: firstIndent - lastIndent } ); + } + + if ( firstNode.isEmpty || !selection.isCollapsed ) { + this.editor.execute( 'delete' ); + } + + if ( !firstNode.isEmpty ) { + mergeListItemBefore( lastNode, firstNode, writer ); + } + + // TODO this._fireAfterExecute() + } ); + } + + /** + * TODO + * + * @private + * @param {Array.} changedBlocks The changed list elements. + */ + _fireAfterExecute( changedBlocks ) { + /** + * Event fired by the {@link #execute} method. + * + * It allows to execute an action after executing the {@link ~DocumentListIndentCommand#execute} method, + * for example adjusting attributes of changed list items. + * + * @protected + * @event afterExecute + */ + this.fire( 'afterExecute', changedBlocks ); + } + + /** + * Checks whether the command can be enabled in the current context. + * + * @private + * @returns {Boolean} Whether the command should be enabled. + */ + _checkEnabled() { + const model = this.editor.model; + const selection = model.document.selection; + const firstPosition = selection.getFirstPosition(); + const firstPositionParent = firstPosition.parent; + const firstNode = selection.isCollapsed ? firstPositionParent.previousSibling : firstPositionParent; + + if ( !firstNode || !firstNode.hasAttribute( 'listItemId' ) ) { + return false; + } + + return firstPosition.isAtStart; + } +} diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 06ef0813f50..dad60c0b084 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -240,13 +240,22 @@ export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { const allBlocks = expand ? expandListBlocksToCompleteItems( blocks ) : blocks; for ( const block of allBlocks ) { - writer.setAttribute( 'listIndent', block.getAttribute( 'listIndent' ) + indentBy, block ); + const blockIndent = block.getAttribute( 'listIndent' ) + indentBy; + + if ( blockIndent < 0 ) { + removeListAttributes( block, writer ); + + continue; + } + + writer.setAttribute( 'listIndent', blockIndent, block ); } return allBlocks; } /** + * TODO * Decreases indentation of given list blocks. * * @protected @@ -256,7 +265,7 @@ export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { * @param {Boolean} [options.expand=false] Whether should expand the list of blocks to include complete list items * (all blocks of given list items). */ -export function outdentBlocks( blocks, writer, { expand } = {} ) { +export function outdentBlocksWithMerge( blocks, writer, { expand } = {} ) { blocks = toArray( blocks ); // Expand the selected blocks to contain the whole list items. From 906dcc38d365f50da86bd5fb2934a651b94e8364 Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Mon, 10 Jan 2022 17:42:06 +0100 Subject: [PATCH 03/44] Cleaning. --- packages/ckeditor5-list/src/documentlist/utils/model.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 5d1001260fc..1247afdb309 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -372,7 +372,7 @@ export function isSingleListItem( blocks ) { * @param {module:engine/model/writer~Writer} writer The model writer. * @returns {Array.} Array of altered blocks. */ -export function outdentFollowingItems( lastBlock, writer, { baseIndent = 0 } = {} ) { +export function outdentFollowingItems( lastBlock, writer ) { const changedBlocks = []; // Start from the model item that is just after the last turned-off item. @@ -431,7 +431,7 @@ export function outdentFollowingItems( lastBlock, writer, { baseIndent = 0 } = { const indent = node.getAttribute( 'listIndent' ); // If the indent is 0 we are not going to change anything anyway. - if ( indent == baseIndent ) { + if ( indent == 0 ) { break; } @@ -443,7 +443,7 @@ export function outdentFollowingItems( lastBlock, writer, { baseIndent = 0 } = { // Fix indent relatively to current relative indent. // Note, that if we just changed the current relative indent, the newIndent will be equal to 0. - const newIndent = indent - currentIndent + baseIndent; + const newIndent = indent - currentIndent; // Save the entry in changes array. We do not apply it at the moment, because we will need to // reverse the changes so the last item is changed first. From cdcb9e98da1a0e8b9243c385dcd0bac829860ac4 Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Tue, 11 Jan 2022 13:51:16 +0100 Subject: [PATCH 04/44] Refactor. --- .../src/documentlist/documentlistmergecommand.js | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 81929be8501..34d8894237d 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -70,7 +70,14 @@ export default class DocumentListMergeCommand extends Command { } if ( firstNode.isEmpty || !selection.isCollapsed ) { - this.editor.execute( 'delete' ); + let sel = selection; + + if ( selection.isCollapsed ) { + sel = writer.createSelection( selection ); + model.modifySelection( sel, { direction: 'backward' } ); + } + + model.deleteContent( sel, { doNotResetEntireContent: true } ); } if ( !firstNode.isEmpty ) { From a9f9754f04bd26743dfa5f9607fabe26c9309244 Mon Sep 17 00:00:00 2001 From: Andrzej Stanek Date: Wed, 12 Jan 2022 14:16:07 +0100 Subject: [PATCH 05/44] Finish is enabled for mergelistcommand --- .../documentlist/documentlistmergecommand.js | 23 +- .../documentlist/documentlistmergecommand.js | 1099 +++++++++++++++++ .../tests/manual/listmocking.js | 4 +- .../ckeditor5-list/theme/documentlist.css | 7 +- 4 files changed, 1122 insertions(+), 11 deletions(-) create mode 100644 packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 34d8894237d..8647a09faf6 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -118,12 +118,29 @@ export default class DocumentListMergeCommand extends Command { const selection = model.document.selection; const firstPosition = selection.getFirstPosition(); const firstPositionParent = firstPosition.parent; - const firstNode = selection.isCollapsed ? firstPositionParent.previousSibling : firstPositionParent; - if ( !firstNode || !firstNode.hasAttribute( 'listItemId' ) ) { + let firstNode; + + if ( selection.isCollapsed ) { + firstNode = firstPosition.isAtEnd ? firstPositionParent.nextSibling : firstPositionParent.previousSibling; + } else { + firstNode = firstPositionParent; + } + + const lastNode = selection.getLastPosition().parent; + + if ( firstNode === lastNode ) { + return false; + } + + if ( !firstNode || !lastNode.hasAttribute( 'listItemId' ) ) { + return false; + } + + if ( selection.isCollapsed && !( firstPosition.isAtStart || firstPosition.isAtEnd ) ) { return false; } - return firstPosition.isAtStart; + return true; } } diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js new file mode 100644 index 00000000000..5dad10d629f --- /dev/null +++ b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js @@ -0,0 +1,1099 @@ +/** + * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license + */ + +import { modelList } from './_utils/utils'; +import DocumentListMergeCommand from '../../src/documentlist/documentlistmergecommand'; + +import Editor from '@ckeditor/ckeditor5-core/src/editor/editor'; +import Model from '@ckeditor/ckeditor5-engine/src/model/model'; + +import DeleteCommand from '@ckeditor/ckeditor5-typing/src/deletecommand'; + +import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; +import { setData, getData } from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; + +describe( 'DocumentListMergeCommand', () => { + let editor, model, doc, command; + + testUtils.createSinonSandbox(); + + beforeEach( () => { + editor = new Editor(); + editor.model = new Model(); + + model = editor.model; + doc = model.document; + doc.createRoot(); + + model.schema.register( 'paragraph', { inheritAllFrom: '$block' } ); + model.schema.register( 'blockQuote', { inheritAllFrom: '$container' } ); + model.schema.extend( '$container', { allowAttributes: [ 'listType', 'listIndent', 'listItemId' ] } ); + command = new DocumentListMergeCommand( editor ); + } ); + + afterEach( () => { + command.destroy(); + } ); + + // TODO add cases for forward delete + describe( 'isEnabled', () => { + describe( 'enabled if', () => { + describe( 'when collapsed selection', () => { + describe( 'selection at the start of a block (backward delete)', () => { + it( 'if preceded by other list item of same indentation', () => { + setData( model, modelList( [ + '* a', + '* []b', + '* c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + + setData( model, modelList( [ + '* a', + '* b', + '* []c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + + setData( model, modelList( [ + '* a', + '* b', + '* c', + '* []d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the beginning of list item that is preceded by other list item of lower indentation', () => { + setData( model, modelList( [ + '* a', + '* b', + ' * []c', + ' * d', + '* e', + '* f' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the beginning of list item that is preceded by other list item of higher indentation', () => { + setData( model, modelList( [ + '* a', + '* b', + ' * c', + ' * d', + ' * []e', + '* f', + '* g' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the beginning of the first block of list item', () => { + setData( model, modelList( [ + '* a', + '* []b', + ' c', + ' d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the beginning of noninitial block of list item', () => { + setData( model, modelList( [ + '* a', + '* b', + ' []c', + ' d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the beginning of the last block of list item', () => { + setData( model, modelList( [ + '* a', + '* b', + ' c', + ' []d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the beginning of noninitial block of list item proceed by indent', () => { + setData( model, modelList( [ + '* a', + ' * b', + ' * c', + ' * d', + ' []e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + } ); + + describe( 'selection at the end of a block (forward delete)', () => { + it( 'if followed by a list item of same indentation', () => { + setData( model, modelList( [ + '* a[]', + '* b', + '* c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + + setData( model, modelList( [ + '* a', + '* b', + '* c[]', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + + setData( model, modelList( [ + '* a', + '* b[]', + '* c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is followed by other list item of higher indentation', () => { + setData( model, modelList( [ + '* a', + '* b', + ' * c[]', + ' * d', + '* e', + '* f' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is followed by a list item of lower indentation', () => { + setData( model, modelList( [ + '* a', + '* b', + ' * c', + ' * d', + ' * e[]', + '* f', + '* g' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the end of the first block of list item', () => { + setData( model, modelList( [ + '* a', + '* b[]', + ' c', + ' d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the end of noninitial block of list item', () => { + setData( model, modelList( [ + '* a', + '* b', + ' c[]', + ' d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection is at the end of the last block of list item that is not part of the last item in a list', () => { + setData( model, modelList( [ + '* a', + '* b', + ' c', + ' d[]', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + } ); + } ); + + describe( 'when non-collapsed selection', () => { + it( 'if selection is spaning only empty list items', () => { + setData( model, modelList( [ + '* foo', + '* [', + '* ]', + ' c' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection starts at the end of list item and ends at the start of another', () => { + setData( model, modelList( [ + '* a[', + '* ]a', + '* b' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'if selection ends at the beginning of another list item', () => { + setData( model, modelList( [ + '* fo[o', + '* ]a', + '* b' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + describe( 'selection starts at the start of a list item', () => { + it( 'should be enabled when selection ends at the end of another list item', () => { + setData( model, modelList( [ + '* [a', + '* b]', + '* c' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of another list item and spans multiple list items', () => { + setData( model, modelList( [ + '* [a', + '* b', + '* c]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of another list item and spans multiple list items (multiple blocks)', () => { + setData( model, modelList( [ + '* [a', + '* b', + ' c', + '* d]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of indented list item', () => { + setData( model, modelList( [ + '* [a', + '* b', + ' * c]', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the non-initial block of a intended list item', () => { + setData( model, modelList( [ + '* [a', + '* b', + ' * c', + ' d]', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection spans intended list item', () => { + setData( model, modelList( [ + '* [a', + '* b', + ' * c', + ' d', + '* e]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends in the middle of list item', () => { + setData( model, modelList( [ + '* [a', + '* te]xt', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + } ); + + describe( 'selection starts at in the middle of a list item', () => { + it( 'should be enabled when selection ends at the end of another list item', () => { + setData( model, modelList( [ + '* te[xt', + '* b]', + '* c' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of another list item and spans multiple list items', () => { + setData( model, modelList( [ + '* te[xt', + '* b', + '* c]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of another list item and spans multiple list items (multiple blocks)', () => { + setData( model, modelList( [ + '* te[xt', + '* b', + ' c', + '* d]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of indented list item', () => { + setData( model, modelList( [ + '* te[xt', + '* b', + ' * c]', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the non-initial block of a intended list item', () => { + setData( model, modelList( [ + '* te[xt', + '* b', + ' * c', + ' d]', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection spans intended list item', () => { + setData( model, modelList( [ + '* te[xt', + '* b', + ' * c', + ' d', + '* e]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends in the middle of list item', () => { + setData( model, modelList( [ + '* te[xt', + '* te]xt', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + } ); + + describe( 'selection starts at the end of a list item', () => { + it( 'should be enabled when selection ends at the end of another list item', () => { + setData( model, modelList( [ + '* a[', + '* b]', + '* c' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of another list item and spans multiple list items', () => { + setData( model, modelList( [ + '* a[', + '* b', + '* c]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of another list item and spans multiple list items (multiple blocks)', () => { + setData( model, modelList( [ + '* a[', + '* b', + ' c', + '* d]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the end of indented list item', () => { + setData( model, modelList( [ + '* a[', + '* b', + ' * c]', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends at the non-initial block of a intended list item', () => { + setData( model, modelList( [ + '* a[', + '* b', + ' * c', + ' d]', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection spans intended list item', () => { + setData( model, modelList( [ + '* a[', + '* b', + ' * c', + ' d', + '* e]' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + + it( 'when selection ends in the middle of list item', () => { + setData( model, modelList( [ + '* a[', + '* te]xt', + '* e' + ] ) ); + + expect( command.isEnabled ).to.be.true; + } ); + } ); + } ); + } ); + + describe( 'disabled', () => { + describe( 'collapsed selection', () => { + it( 'if selection is at the beginning of the first list item of a list', () => { + setData( model, modelList( [ + '* []a', + '* b', + '* c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + + it( 'if selection is not at the beginning nor end of a list item', () => { + setData( model, modelList( [ + '* te[]xt', + '* b', + '* c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.false; + + setData( model, modelList( [ + '* a', + '* te[]xt', + '* c', + '* d' + ] ) ); + + expect( command.isEnabled ).to.be.false; + + setData( model, modelList( [ + '* a', + '* b', + '* c', + '* te[]xt' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + + it( 'if selection is not at the beginning nor end of a block', () => { + setData( model, modelList( [ + '* a', + '* b', + ' te[]xt' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + + it( 'if selection is outside list', () => { + setData( model, modelList( [ + 'foo[]', + '* a', + '* b', + ' c' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + } ); + + describe( 'non-collapsed selection', () => { + it( 'if selection is spaning whole single list item', () => { + setData( model, modelList( [ + '* [foo]', + '* a', + '* b', + ' c' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + + it( 'if selection is spaning part of single list item', () => { + setData( model, modelList( [ + '* f[oo]oo', + '* a', + '* b', + ' c' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + + it( 'if selection is spaning the middle and the end of list item', () => { + setData( model, modelList( [ + '* fo[ooo]', + '* a', + '* b', + ' c' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + + it( 'if selection is spaning the start and the middle of single list item', () => { + setData( model, modelList( [ + '* [foo]oo', + '* a', + '* b', + ' c' + ] ) ); + + expect( command.isEnabled ).to.be.false; + } ); + } ); + } ); + } ); + + describe( 'execute()', () => { + describe( 'backward delete', () => { + let deleteCommand; + + beforeEach( () => { + deleteCommand = new DeleteCommand( editor, 'backward' ); + editor.commands.add( 'delete', deleteCommand ); + } ); + + afterEach( () => { + deleteCommand.destroy(); + } ); + + describe( 'collapsed selection at the beginning of a list item', () => { + describe( 'item before is empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setData( model, modelList( [ + '* ', + '* []b' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:001}' + ] ) ); + } ); + + it( 'should merge empty list item with with previous empty list item', () => { + setData( model, modelList( [ + '* ', + '* []' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setData( model, modelList( [ + '* ', + ' * []a' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []a{id:001}' + ] ) ); + } ); + + it( 'should merge indented empty list item with with previous empty list item', () => { + setData( model, modelList( [ + '* ', + ' * []' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setData( model, modelList( [ + '* ', + ' * ', + '* []a' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setData( model, modelList( [ + '* ', + ' * ', + '* []' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setData( model, modelList( [ + '* a', + '* []b' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + } ); + + it( 'should merge empty list item with with previous list item as a block', () => { + setData( model, modelList( [ + '* a', + '* []' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + } ); + + it( 'should merge indented list item with with parent list item as a block', () => { + setData( model, modelList( [ + '* a', + ' * []b' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + } ); + + it( 'should merge indented empty list item with with parent list item as a block', () => { + setData( model, modelList( [ + '* a', + ' * []' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + } ); + + it( 'should merge list item with with previous list item with higher indent as a block', () => { + setData( model, modelList( [ + '* a', + ' * b', + '* []c' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c' + ] ) ); + } ); + + it( 'should merge empty list item with with previous list item with higher indent as a block', () => { + setData( model, modelList( [ + '* a', + ' * b', + '* []' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []' + ] ) ); + } ); + + it( 'should keep merged list item\'s children', () => { + setData( model, modelList( [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + } ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setData( model, modelList( [ + '* [', + '* ]' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setData( model, modelList( [ + '* [{id:002}', + '* a', + ' * ]b' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []{id:002}', + ' b' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + // fix expected + it( 'should delete all items till the end of selection and merge last list item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []d{id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + } ); + + describe( 'non-empty block', () => { + it( 'should merge two list items', () => { + setData( model, modelList( [ + '* [text', + '* ano]ther' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []ther' + ] ) ); + } ); + + // Not related to merge command + it( 'should merge two list itemsx', () => { + setData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * ]b', + ' * c' + ] ) ); + + command.execute(); + // output is okay, fix expect + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:002}', + ' * c{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + command.execute(); + + // output is okay, fix expect + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []d{id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + command.execute(); + + expect( getData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + } ); + } ); + + describe( 'selection at the beginning of a block', () => { + + } ); + } ); + + describe( 'forward delete', () => { + + } ); + } ); +} ); diff --git a/packages/ckeditor5-list/tests/manual/listmocking.js b/packages/ckeditor5-list/tests/manual/listmocking.js index c19c0fe98db..a71ef57491c 100644 --- a/packages/ckeditor5-list/tests/manual/listmocking.js +++ b/packages/ckeditor5-list/tests/manual/listmocking.js @@ -158,7 +158,7 @@ const onPaste = () => { } }; -const onHighlighChange = () => { +const onHighlightChange = () => { document.querySelector( '.ck-editor' ).classList.toggle( 'highlight-lists' ); }; @@ -166,5 +166,5 @@ document.getElementById( 'btn-process-input' ).addEventListener( 'click', proces document.getElementById( 'btn-process-editor-model' ).addEventListener( 'click', processEditorModel ); document.getElementById( 'btn-copy-output' ).addEventListener( 'click', copyOutput ); document.getElementById( 'data-input' ).addEventListener( 'paste', onPaste ); -document.getElementById( 'chbx-highlight-lists' ).addEventListener( 'change', onHighlighChange ); +document.getElementById( 'chbx-highlight-lists' ).addEventListener( 'change', onHighlightChange ); diff --git a/packages/ckeditor5-list/theme/documentlist.css b/packages/ckeditor5-list/theme/documentlist.css index b81200285d0..965ce9d501c 100644 --- a/packages/ckeditor5-list/theme/documentlist.css +++ b/packages/ckeditor5-list/theme/documentlist.css @@ -8,10 +8,5 @@ * Use display:inline-block to force Chrome/Safari to limit text mutations to this element. * See https://github.com/ckeditor/ckeditor5/issues/6062. */ - display: inline-block; - - /* - * Make it possible to click the whole line to put selection inside it. - */ - width: 100%; + display: block; } From c341ec921efc9cb850e011ad3f9d065ed36cf66d Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Thu, 13 Jan 2022 22:12:20 +0100 Subject: [PATCH 06/44] Backspace handling. --- .../src/documentlist/documentlistediting.js | 77 +- .../documentlist/documentlistmergecommand.js | 96 +- .../src/documentlist/utils/model.js | 16 +- .../tests/documentlist/_utils-tests/utils.js | 7 + .../tests/documentlist/_utils/utils.js | 7 + .../documentlistediting-integrations.js | 878 +++++++++++++++++- .../tests/documentlist/utils/model.js | 432 ++++----- 7 files changed, 1222 insertions(+), 291 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 52c5fcc5604..592b82377b9 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -32,7 +32,8 @@ import { import { getAllListItemBlocks, isFirstBlockOfListItem, - isLastBlockOfListItem + isLastBlockOfListItem, + isSingleListItem } from './utils/model'; import { iterateSiblingListBlocks } from './utils/listwalker'; @@ -94,52 +95,52 @@ export default class DocumentListEditing extends Plugin { editor.commands.add( 'indentList', new DocumentListIndentCommand( editor, 'forward' ) ); editor.commands.add( 'outdentList', new DocumentListIndentCommand( editor, 'backward' ) ); - editor.commands.add( 'mergeListItem', new DocumentListMergeCommand( editor ) ); - editor.commands.add( 'splitListItem', new DocumentListSplitCommand( editor ) ); + editor.commands.add( 'mergeListItemBackward', new DocumentListMergeCommand( editor, 'backward' ) ); + editor.commands.add( 'mergeListItemForward', new DocumentListMergeCommand( editor, 'forward' ) ); + editor.commands.add( 'splitListItemBefore', new DocumentListSplitCommand( editor, 'before' ) ); editor.commands.add( 'splitListItemAfter', new DocumentListSplitCommand( editor, 'after' ) ); this.listenTo( editor.editing.view.document, 'delete', ( evt, data ) => { - if ( data.direction !== 'backward' ) { - return; - } - - const mergeListCommand = editor.commands.get( 'mergeListItem' ); - - if ( mergeListCommand.isEnabled ) { - mergeListCommand.execute(); - - data.preventDefault(); - evt.stop(); - - return; - } - const selection = editor.model.document.selection; - - if ( !selection.isCollapsed ) { - return; - } - const firstPosition = selection.getFirstPosition(); - - if ( !firstPosition.isAtStart ) { - return; - } - const positionParent = firstPosition.parent; - if ( !positionParent.hasAttribute( 'listItemId' ) ) { - return; - } - - const previousIsAListItem = positionParent.previousSibling && positionParent.previousSibling.hasAttribute( 'listItemId' ); - - if ( previousIsAListItem ) { - return; - } + editor.model.change( () => { + if ( selection.isCollapsed ) { + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return; + } - this.editor.execute( 'outdentList' ); + // TODO what about different list types? + + if ( data.direction == 'backward' && firstPosition.isAtStart ) { + const previousSibling = positionParent.previousSibling; + const previousSiblingIsSameListItem = isSingleListItem( [ positionParent, previousSibling ] ); + + // Merge block with previous one (on the block level or on the content level). + if ( previousSibling && previousSibling.hasAttribute( 'listItemId' ) ) { + editor.execute( 'mergeListItemBackward', { + deleteContent: previousSibling.isEmpty || previousSiblingIsSameListItem + } ); + } + // Outdent the first block of a first list item. + else { + if ( !isLastBlockOfListItem( positionParent ) ) { + editor.execute( 'splitListItemAfter' ); + } + + editor.execute( 'outdentList' ); + } + + data.preventDefault(); + evt.stop(); + } else if ( data.direction == 'forward' && firstPosition.isAtEnd ) { + // TODO + throw new Error( 'not yet' ); + } + } + } ); }, { context: 'li' } ); // Overwrite the default Enter key behavior: outdent or split the list in certain cases. diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 8647a09faf6..01e84e765ec 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -9,9 +9,10 @@ import { Command } from 'ckeditor5/src/core'; import { - indentBlocks, + indentBlocks, isFirstBlockOfListItem, mergeListItemBefore } from './utils/model'; +import ListWalker from './utils/listwalker'; /** * TODO @@ -20,11 +21,30 @@ import { * @extends module:core/command~Command */ export default class DocumentListMergeCommand extends Command { + /** + * Creates an instance of the command. + * + * @param {module:core/editor/editor~Editor} editor The editor instance. + * @param {'backward'|'forward'} direction Whether list item should be merged before or after the selected block. + */ + constructor( editor, direction ) { + super( editor ); + + /** + * Whether list item should be merged before or after the selected block. + * + * @readonly + * @private + * @member {'backward'|'forward'} + */ + this._direction = direction; + } + /** * @inheritDoc */ refresh() { - this.isEnabled = this._checkEnabled(); + this.isEnabled = true; // this._checkEnabled(); } /** @@ -33,55 +53,61 @@ export default class DocumentListMergeCommand extends Command { * @fires execute * @fires afterExecute */ - execute() { + execute( { deleteContent = false } = {} ) { const model = this.editor.model; const selection = model.document.selection; - // Backspace handling - // - Collapsed selection at the beginning of the first item of list - // -> outdent command - // - Collapsed selection at the beginning of the first block of an item - // - Item before is empty - // -> change indent to match previous (with sub lists) - // -> standard delete command - // - Item before is not empty - // -> change indent to match previous - // -> merge block with previous item - // - Non-collapsed selection with first position in the first block of a list item and the last position in other item - // - first position in empty block - // -> change indent of the last block to match the first block - // -> standard delete command - // - first position in non-empty block - // -> change indent of the last block to match the first block - // -> standard delete command - // -> merge last block with the first block - model.change( writer => { - const firstPosition = selection.getFirstPosition(); - const firstPositionParent = firstPosition.parent; - const firstNode = selection.isCollapsed ? firstPositionParent.previousSibling : firstPositionParent; - const lastNode = selection.getLastPosition().parent; + const anchorElement = selection.getFirstPosition().parent; + const isFirstBlock = isFirstBlockOfListItem( anchorElement ); + let firstElement, lastElement; + + // TODO what about different list types? + + if ( this._direction == 'backward' ) { + lastElement = anchorElement; + firstElement = isFirstBlock && !deleteContent ? + ListWalker.first( anchorElement, { sameIndent: true, lowerIndent: true } ) : + anchorElement.previousSibling; + } else { + // TODO + firstElement = anchorElement; + lastElement = anchorElement.nextSibling; + } - const firstIndent = firstNode.getAttribute( 'listIndent' ); - const lastIndent = lastNode.getAttribute( 'listIndent' ); + const firstIndent = firstElement.getAttribute( 'listIndent' ); + const lastIndent = lastElement.getAttribute( 'listIndent' ); if ( firstIndent != lastIndent ) { - indentBlocks( lastNode, writer, { expand: true, indentBy: firstIndent - lastIndent } ); + indentBlocks( lastElement, writer, { + indentBy: firstIndent - lastIndent, + expand: 'forward' + } ); } - if ( firstNode.isEmpty || !selection.isCollapsed ) { + if ( deleteContent ) { let sel = selection; if ( selection.isCollapsed ) { - sel = writer.createSelection( selection ); - model.modifySelection( sel, { direction: 'backward' } ); + sel = writer.createSelection( writer.createRange( + writer.createPositionAt( firstElement, 'end' ), + writer.createPositionAt( lastElement, 0 ) + ) ); } + const lastElementId = lastElement.getAttribute( 'listItemId' ); + model.deleteContent( sel, { doNotResetEntireContent: true } ); - } - if ( !firstNode.isEmpty ) { - mergeListItemBefore( lastNode, firstNode, writer ); + // Find the last element (it could be moved to graveyard). + const lastElementAfterDelete = lastElement.root.rootName != '$graveyard' ? lastElement : firstElement; + const nextSibling = lastElementAfterDelete.nextSibling; + + if ( nextSibling && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { + mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ); + } + } else { + mergeListItemBefore( lastElement, firstElement, writer ); } // TODO this._fireAfterExecute() diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 1247afdb309..35ff1aa407d 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -169,11 +169,21 @@ export function expandListBlocksToCompleteItems( blocks, options = {} ) { blocks = toArray( blocks ); const higherIndent = options.withNested !== false; + const expandForward = options.direction != 'backward'; + const expandBackward = options.direction != 'forward'; const allBlocks = new Set(); for ( const block of blocks ) { - for ( const itemBlock of getAllListItemBlocks( block, { higherIndent } ) ) { - allBlocks.add( itemBlock ); + if ( expandBackward ) { + for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'backward' } ) ) { + allBlocks.add( itemBlock ); + } + } + + if ( expandForward ) { + for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'forward' } ) ) { + allBlocks.add( itemBlock ); + } } } @@ -241,7 +251,7 @@ export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { blocks = toArray( blocks ); // Expand the selected blocks to contain the whole list items. - const allBlocks = expand ? expandListBlocksToCompleteItems( blocks ) : blocks; + const allBlocks = expand ? expandListBlocksToCompleteItems( blocks, { direction: expand == true ? 'both' : expand } ) : blocks; for ( const block of allBlocks ) { const blockIndent = block.getAttribute( 'listIndent' ) + indentBy; diff --git a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js index e224ff1ff68..274377f356a 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js @@ -281,6 +281,13 @@ describe( 'mockList()', () => { ' baz' ] ) ).to.throw( Error, 'Invalid indent: bar' ); } ); + + it( 'should throw when ID is reused', () => { + expect( () => modelList( [ + '* foo', + '* bar {id:000}' + ] ) ).to.throw( Error, 'ID conflict: 000' ); + } ); } ); describe( 'stringifyList()', () => { diff --git a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js index 2162490a50c..b4be24242c1 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js @@ -222,6 +222,7 @@ export function setupTestHelpers( editor ) { export function modelList( lines ) { const items = []; const stack = []; + const seenIds = new Set(); let prevIndent = -1; @@ -251,6 +252,12 @@ export function modelList( lines ) { return ''; } ); + if ( seenIds.has( listItemId ) ) { + throw new Error( 'ID conflict: ' + listItemId ); + } + + seenIds.add( listItemId ); + stack[ listIndent ] = { listItemId, listType: marker == '#' ? 'numbered' : 'bulleted' diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index 8ed6fe8b972..6c55647dcac 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -16,12 +16,17 @@ import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; import EventInfo from '@ckeditor/ckeditor5-utils/src/eventinfo'; import VirtualTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/virtualtesteditor'; -import { getData as getModelData, parse as parseModel, setData as setModelData } from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; +import { + getData as getModelData, + parse as parseModel, + setData as setModelData +} from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; import { parse as parseView } from '@ckeditor/ckeditor5-engine/src/dev-utils/view'; import { DomEventData } from '@ckeditor/ckeditor5-engine'; import stubUid from './_utils/uid'; import { modelList } from './_utils/utils'; +import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubblingeventinfo'; describe( 'DocumentListEditing integrations', () => { let editor, model, modelDoc, modelRoot, view; @@ -1780,4 +1785,875 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); } ); + + describe( 'backspace key handling', () => { + const changedBlocks = []; + let domEventData, mergeCommand, splitAfterCommand, indentCommand, + eventInfo, mergeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; + + beforeEach( () => { + eventInfo = new BubblingEventInfo( view.document, 'delete' ); + domEventData = new DomEventData( view, { + preventDefault: sinon.spy() + }, { + direction: 'backward', + unit: 'codePoint', + sequence: 1 + } ); + + splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); + indentCommand = editor.commands.get( 'outdentList' ); + mergeCommand = editor.commands.get( 'mergeListItemBackward' ); + + splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); + outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); + mergeCommandExecuteSpy = sinon.spy( mergeCommand, 'execute' ); + + changedBlocks.length = 0; + + splitAfterCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + indentCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + mergeCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + } ); + + describe( 'collapsed selection', () => { + describe( 'at the beginning of a list item', () => { + describe( 'single block list item', () => { + describe( 'item before is empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* ', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b {id:001}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + // Default behaviour of backspace? + it( 'should merge empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a{id:001}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should keep merged list item\'s children', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + } ); + + describe( 'multi-block list item', () => { + describe( 'item before is empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:001}', + ' c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with first block empty with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []', + ' a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' a' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should TODO', () => { + setModelData( model, modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with first block empty with previous list item', () => { + setModelData( model, modelList( [ + '* a', + '* []', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous list item as blocks', () => { + setModelData( model, modelList( [ + '* a', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []a', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list having block and indented list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c', + ' d' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + } ); + } ); + } ); + + describe( 'non-collapsed selection', () => { + // TODO + } ); + } ); } ); diff --git a/packages/ckeditor5-list/tests/documentlist/utils/model.js b/packages/ckeditor5-list/tests/documentlist/utils/model.js index ae72a03ccb0..e3f91f2ceda 100644 --- a/packages/ckeditor5-list/tests/documentlist/utils/model.js +++ b/packages/ckeditor5-list/tests/documentlist/utils/model.js @@ -15,7 +15,7 @@ import { isSingleListItem, ListItemUid, mergeListItemBefore, - outdentBlocks, + outdentBlocksWithMerge, outdentFollowingItems, removeListAttributes, splitListItemBefore @@ -1075,229 +1075,233 @@ describe( 'DocumentList - utils - model', () => { } ); describe( 'indentBlocks()', () => { - it( 'flat items', () => { - const input = modelList( [ - '* a', - ' b', - '* c', - ' d' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 1 ), - fragment.getChild( 2 ) - ]; - - stubUid(); - - model.change( writer => indentBlocks( blocks, writer ) ); - - expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ - '* a', - ' * b{000}', - ' * c', - '* d{002}' - ] ) ); - } ); - - it( 'nested lists should keep structure', () => { - const input = modelList( [ - '* a', - ' * b', - ' * c', - ' * d', - '* e' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 1 ), - fragment.getChild( 2 ), - fragment.getChild( 3 ) - ]; - - stubUid(); - - model.change( writer => indentBlocks( blocks, writer ) ); - - expect( stringifyModel( fragment ) ).to.equal( modelList( [ - '* a', - ' * b', - ' * c', - ' * d', - '* e' - ] ) ); - } ); - - it( 'should apply indentation on all blocks of given items (expand = true)', () => { - const input = modelList( [ - '* 0', - '* 1', - ' 2', - '* 3', - ' 4', - '* 5' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 2 ), - fragment.getChild( 3 ) - ]; - - model.change( writer => indentBlocks( blocks, writer, { expand: true } ) ); - - expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ - '* 0', - ' * 1', - ' 2', - ' * 3', - ' 4', - '* 5' - ] ) ); - } ); - } ); - - describe( 'outdentBlocks()', () => { - it( 'should handle outdenting', () => { - const input = modelList( [ - '* 0', - ' * 1', - ' * 2', - ' * 3', - '* 4' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 1 ), - fragment.getChild( 2 ), - fragment.getChild( 3 ) - ]; - - let changedBlocks; - - model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer ); + describe( 'indentBy = 1', () => { + it( 'flat items', () => { + const input = modelList( [ + '* a', + ' b', + '* c', + ' d' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 1 ), + fragment.getChild( 2 ) + ]; + + stubUid(); + + model.change( writer => indentBlocks( blocks, writer ) ); + + expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ + '* a', + ' * b{000}', + ' * c', + '* d{002}' + ] ) ); } ); - expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ - '* 0', - '* 1', - ' * 2', - '* 3', - '* 4' - ] ) ); - - expect( changedBlocks ).to.deep.equal( blocks ); - } ); - - it( 'should remove list attributes if outdented below 0', () => { - const input = modelList( [ - '* 0', - '* 1', - '* 2', - ' * 3', - '* 4' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 2 ), - fragment.getChild( 3 ), - fragment.getChild( 4 ) - ]; - - let changedBlocks; - - model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer ); + it( 'nested lists should keep structure', () => { + const input = modelList( [ + '* a', + ' * b', + ' * c', + ' * d', + '* e' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 1 ), + fragment.getChild( 2 ), + fragment.getChild( 3 ) + ]; + + stubUid(); + + model.change( writer => indentBlocks( blocks, writer ) ); + + expect( stringifyModel( fragment ) ).to.equal( modelList( [ + '* a', + ' * b', + ' * c', + ' * d', + '* e' + ] ) ); } ); - expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ - '* 0', - '* 1', - '2', - '* 3', - '4' - ] ) ); - - expect( changedBlocks ).to.deep.equal( blocks ); - } ); - - it( 'should not remove attributes other than lists if outdented below 0', () => { - const input = modelList( [ - '* 0', - '* 1', - ' * 2', - '* 3', - ' * 4' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 2 ), - fragment.getChild( 3 ), - fragment.getChild( 4 ) - ]; - - let changedBlocks; - - model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer ); + it( 'should apply indentation on all blocks of given items (expand = true)', () => { + const input = modelList( [ + '* 0', + '* 1', + ' 2', + '* 3', + ' 4', + '* 5' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 2 ), + fragment.getChild( 3 ) + ]; + + model.change( writer => indentBlocks( blocks, writer, { expand: true } ) ); + + expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ + '* 0', + ' * 1', + ' 2', + ' * 3', + ' 4', + '* 5' + ] ) ); } ); - - expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ - '* 0', - '* 1', - '* 2', - '3', - '* 4' - ] ) ); - - expect( changedBlocks ).to.deep.equal( blocks ); } ); - it( 'should apply indentation on all blocks of given items (expand = true)', () => { - const input = modelList( [ - '* 0', - ' * 1', - ' 2', - ' * 3', - ' 4', - ' * 5' - ] ); - - const fragment = parseModel( input, schema ); - const blocks = [ - fragment.getChild( 2 ), - fragment.getChild( 3 ) - ]; - - let changedBlocks; + describe( 'indentBy = -1', () => { + it( 'should handle outdenting', () => { + const input = modelList( [ + '* 0', + ' * 1', + ' * 2', + ' * 3', + '* 4' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 1 ), + fragment.getChild( 2 ), + fragment.getChild( 3 ) + ]; + + let changedBlocks; + + model.change( writer => { + changedBlocks = indentBlocks( blocks, writer, { indentBy: -1 } ); + } ); + + expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ + '* 0', + '* 1', + ' * 2', + '* 3', + '* 4' + ] ) ); + + expect( changedBlocks ).to.deep.equal( blocks ); + } ); - model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer, { expand: true } ); + it( 'should remove list attributes if outdented below 0', () => { + const input = modelList( [ + '* 0', + '* 1', + '* 2', + ' * 3', + '* 4' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 2 ), + fragment.getChild( 3 ), + fragment.getChild( 4 ) + ]; + + let changedBlocks; + + model.change( writer => { + changedBlocks = indentBlocks( blocks, writer, { indentBy: -1 } ); + } ); + + expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ + '* 0', + '* 1', + '2', + '* 3', + '4' + ] ) ); + + expect( changedBlocks ).to.deep.equal( blocks ); } ); - expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ - '* 0', - '* 1', - ' 2', - '* 3', - ' 4', - ' * 5' - ] ) ); + it( 'should not remove attributes other than lists if outdented below 0', () => { + const input = modelList( [ + '* 0', + '* 1', + ' * 2', + '* 3', + ' * 4' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 2 ), + fragment.getChild( 3 ), + fragment.getChild( 4 ) + ]; + + let changedBlocks; + + model.change( writer => { + changedBlocks = indentBlocks( blocks, writer, { indentBy: -1 } ); + } ); + + expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ + '* 0', + '* 1', + '* 2', + '3', + '* 4' + ] ) ); + + expect( changedBlocks ).to.deep.equal( blocks ); + } ); - expect( changedBlocks ).to.deep.equal( [ - fragment.getChild( 1 ), - fragment.getChild( 2 ), - fragment.getChild( 3 ), - fragment.getChild( 4 ) - ] ); + it( 'should apply indentation on all blocks of given items (expand = true)', () => { + const input = modelList( [ + '* 0', + ' * 1', + ' 2', + ' * 3', + ' 4', + ' * 5' + ] ); + + const fragment = parseModel( input, schema ); + const blocks = [ + fragment.getChild( 2 ), + fragment.getChild( 3 ) + ]; + + let changedBlocks; + + model.change( writer => { + changedBlocks = indentBlocks( blocks, writer, { expand: true, indentBy: -1 } ); + } ); + + expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ + '* 0', + '* 1', + ' 2', + '* 3', + ' 4', + ' * 5' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + fragment.getChild( 1 ), + fragment.getChild( 2 ), + fragment.getChild( 3 ), + fragment.getChild( 4 ) + ] ); + } ); } ); + } ); + describe( 'outdentBlocksWithMerge()', () => { it( 'should merge nested items to the parent item if nested block is not the last block of parent list item', () => { const input = modelList( [ '* 0', @@ -1315,7 +1319,7 @@ describe( 'DocumentList - utils - model', () => { let changedBlocks; model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer, { expand: true } ); + changedBlocks = outdentBlocksWithMerge( blocks, writer, { expand: true } ); } ); expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ @@ -1349,7 +1353,7 @@ describe( 'DocumentList - utils - model', () => { let changedBlocks; model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer, { expand: true } ); + changedBlocks = outdentBlocksWithMerge( blocks, writer, { expand: true } ); } ); expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ @@ -1383,7 +1387,7 @@ describe( 'DocumentList - utils - model', () => { let changedBlocks; model.change( writer => { - changedBlocks = outdentBlocks( blocks, writer, { expand: true } ); + changedBlocks = outdentBlocksWithMerge( blocks, writer, { expand: true } ); } ); expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ From b8c7489f21472714229b833785c9515094b93b48 Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Fri, 14 Jan 2022 08:56:28 +0100 Subject: [PATCH 07/44] Code cleaning. --- .../src/documentlist/documentlistmergecommand.js | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 01e84e765ec..770617c4927 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -63,6 +63,7 @@ export default class DocumentListMergeCommand extends Command { let firstElement, lastElement; // TODO what about different list types? + // TODO handle non-collapsed selection if ( this._direction == 'backward' ) { lastElement = anchorElement; @@ -77,6 +78,7 @@ export default class DocumentListMergeCommand extends Command { const firstIndent = firstElement.getAttribute( 'listIndent' ); const lastIndent = lastElement.getAttribute( 'listIndent' ); + const lastElementId = lastElement.getAttribute( 'listItemId' ); if ( firstIndent != lastIndent ) { indentBlocks( lastElement, writer, { @@ -95,12 +97,13 @@ export default class DocumentListMergeCommand extends Command { ) ); } - const lastElementId = lastElement.getAttribute( 'listItemId' ); - model.deleteContent( sel, { doNotResetEntireContent: true } ); - // Find the last element (it could be moved to graveyard). - const lastElementAfterDelete = lastElement.root.rootName != '$graveyard' ? lastElement : firstElement; + // Get the last "touched" element after deleteContent call (can't use the lastElement because + // it could get merged into the firstElement while deleting content). + const lastElementAfterDelete = sel.getLastPosition().parent; + + // Check if the element after it was in the same list item and adjust it if needed. const nextSibling = lastElementAfterDelete.nextSibling; if ( nextSibling && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { From 48ddf7672d9f7b5f5f2ef1f9553ba5a4ad0f9f67 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 18 Jan 2022 13:30:18 +0100 Subject: [PATCH 08/44] Backspace handling for non-collapsed selections. --- .../src/documentlist/documentlistediting.js | 17 +- .../documentlist/documentlistmergecommand.js | 30 +- .../documentlistediting-integrations.js | 1560 ++++++++++++----- 3 files changed, 1134 insertions(+), 473 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 592b82377b9..6e52f26c958 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -103,11 +103,12 @@ export default class DocumentListEditing extends Plugin { this.listenTo( editor.editing.view.document, 'delete', ( evt, data ) => { const selection = editor.model.document.selection; - const firstPosition = selection.getFirstPosition(); - const positionParent = firstPosition.parent; editor.model.change( () => { if ( selection.isCollapsed ) { + const firstPosition = selection.getFirstPosition(); + const positionParent = firstPosition.parent; + if ( !positionParent.hasAttribute( 'listItemId' ) ) { return; } @@ -139,6 +140,18 @@ export default class DocumentListEditing extends Plugin { // TODO throw new Error( 'not yet' ); } + } else { + if ( data.direction == 'backward' ) { + editor.execute( 'mergeListItemBackward', { + deleteContent: true + } ); + + data.preventDefault(); + evt.stop(); + } else { + // TODO + throw new Error( 'not yet' ); + } } } ); }, { context: 'li' } ); diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 770617c4927..b8f29fd5c08 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -66,10 +66,18 @@ export default class DocumentListMergeCommand extends Command { // TODO handle non-collapsed selection if ( this._direction == 'backward' ) { - lastElement = anchorElement; - firstElement = isFirstBlock && !deleteContent ? - ListWalker.first( anchorElement, { sameIndent: true, lowerIndent: true } ) : - anchorElement.previousSibling; + if ( selection.isCollapsed ) { + lastElement = anchorElement; + + if ( isFirstBlock && !deleteContent ) { + firstElement = ListWalker.first( anchorElement, { sameIndent: true, lowerIndent: true } ); + } else { + firstElement = anchorElement.previousSibling; + } + } else { + firstElement = selection.getFirstPosition().parent; + lastElement = selection.getLastPosition().parent; + } } else { // TODO firstElement = anchorElement; @@ -83,12 +91,13 @@ export default class DocumentListMergeCommand extends Command { if ( firstIndent != lastIndent ) { indentBlocks( lastElement, writer, { indentBy: firstIndent - lastIndent, - expand: 'forward' + expand: isFirstBlock ? 'forward' : false } ); } if ( deleteContent ) { let sel = selection; + const wasSelectionCollapsed = sel.isCollapsed; if ( selection.isCollapsed ) { sel = writer.createSelection( writer.createRange( @@ -108,6 +117,17 @@ export default class DocumentListMergeCommand extends Command { if ( nextSibling && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ); + + // Note: Using cached selection state because deleteContent will collapse the selection. + // If last element was empty, it would land in the graveyard. + if ( !wasSelectionCollapsed && lastElement.root === firstElement.root ) { + sel = writer.createSelection( writer.createRange( + writer.createPositionAt( firstElement, 'end' ), + writer.createPositionAt( lastElement, 0 ) + ) ); + + model.deleteContent( sel, { doNotResetEntireContent: true } ); + } } } else { mergeListItemBefore( lastElement, firstElement, writer ); diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index 6c55647dcac..f25bf23c69d 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -1789,7 +1789,8 @@ describe( 'DocumentListEditing integrations', () => { describe( 'backspace key handling', () => { const changedBlocks = []; let domEventData, mergeCommand, splitAfterCommand, indentCommand, - eventInfo, mergeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; + eventInfo; + // mergeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; beforeEach( () => { eventInfo = new BubblingEventInfo( view.document, 'delete' ); @@ -1805,9 +1806,9 @@ describe( 'DocumentListEditing integrations', () => { indentCommand = editor.commands.get( 'outdentList' ); mergeCommand = editor.commands.get( 'mergeListItemBackward' ); - splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); - outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); - mergeCommandExecuteSpy = sinon.spy( mergeCommand, 'execute' ); + // splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); + // outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); + // mergeCommandExecuteSpy = sinon.spy( mergeCommand, 'execute' ); changedBlocks.length = 0; @@ -1824,9 +1825,9 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); - describe( 'collapsed selection', () => { - describe( 'at the beginning of a list item', () => { - describe( 'single block list item', () => { + describe( 'backward delete', () => { + describe( 'single block list item', () => { + describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { it( 'should merge non empty list item with with previous list item as a block', () => { setModelData( model, modelList( [ @@ -1837,19 +1838,8 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b {id:001}' + '* []b{id:001}' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); // Default behaviour of backspace? @@ -1864,17 +1854,6 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge indented list item with with previous empty list item', () => { @@ -1888,17 +1867,6 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []a{id:001}' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge indented empty list item with with previous empty list item', () => { @@ -1912,17 +1880,6 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge list item with with previous indented empty list item', () => { @@ -1938,17 +1895,6 @@ describe( 'DocumentListEditing integrations', () => { '* ', ' * []a{id:002}' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { @@ -1964,17 +1910,6 @@ describe( 'DocumentListEditing integrations', () => { '* ', ' * []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); } ); @@ -1991,17 +1926,6 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []b' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge empty list item with with previous list item as a block', () => { @@ -2016,17 +1940,6 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge indented list item with with parent list item as a block', () => { @@ -2041,17 +1954,6 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []b' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge indented empty list item with with parent list item as a block', () => { @@ -2066,17 +1968,6 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge list item with with previous list item with higher indent as a block', () => { @@ -2093,17 +1984,6 @@ describe( 'DocumentListEditing integrations', () => { ' * b', ' []c' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge empty list item with with previous list item with higher indent as a block', () => { @@ -2120,17 +2000,6 @@ describe( 'DocumentListEditing integrations', () => { ' * b', ' []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should keep merged list item\'s children', () => { @@ -2157,503 +2026,1262 @@ describe( 'DocumentListEditing integrations', () => { ' * g', ' h' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); } ); } ); - describe( 'multi-block list item', () => { - describe( 'item before is empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* ', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge with previous list item and keep complex blocks intact', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { setModelData( model, modelList( [ '* ', - '* []b{id:b}', - ' c', - ' * d{id:d}', - ' e', - ' * f{id:f}', - ' * g{id:g}', - ' h', - ' * i{id:i}', - ' * j{id:j}', - ' k', - ' l' + '* []b' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:b}', - ' c', - ' * d{id:d}', - ' e', - ' * f{id:f}', - ' * g{id:g}', - ' h', - ' * i{id:i}', - ' * j{id:j}', - ' k', - ' l' + '* []b{id:001}' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge list item with first block empty with previous empty list item', () => { + // Default behaviour of backspace? + it( 'should merge empty list item with with previous empty list item', () => { setModelData( model, modelList( [ '* ', - '* []', - ' a' + '* []' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' a' + '* []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge indented list item with with previous empty list item', () => { setModelData( model, modelList( [ '* ', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b', - ' * c' + ' * []a' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b', - ' * c {id:003}' + '* []a{id:001}' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge indented empty list item with previous empty list item', () => { + it( 'should merge indented empty list item with with previous empty list item', () => { setModelData( model, modelList( [ '* ', - ' * []', - ' text' + ' * []' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' + '* []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge list item with with previous indented empty list item', () => { setModelData( model, modelList( [ '* ', ' * ', - '* []a', - ' b' + '* []a' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* ', - ' * []a{id:002}', - ' b' + ' * []a{id:002}' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { setModelData( model, modelList( [ '* ', ' * ', - '* []', - ' text' + '* []' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* ', - ' * []', - ' text' + ' * []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); } ); describe( 'item before is not empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { setModelData( model, modelList( [ '* a', - '* []b', - ' c' + '* []b' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a', - ' []b', - ' c' + ' []b' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should TODO', () => { + it( 'should merge empty list item with with previous list item as a block', () => { setModelData( model, modelList( [ - '* b', - ' * c', - ' []d', - ' e' + '* a', + '* []' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' []d', - ' e' + '* a', + ' []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge with previous list item and keep complex blocks intact', () => { + it( 'should merge indented list item with with parent list item as a block', () => { setModelData( model, modelList( [ '* a', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' + ' * []b' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a', - ' []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' + ' []b' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge list item with first block empty with previous list item', () => { + it( 'should merge indented empty list item with with parent list item as a block', () => { setModelData( model, modelList( [ '* a', - '* []', - ' b' + ' * []' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a', - ' []', - ' b' + ' []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge indented list item with with previous list item as blocks', () => { + it( 'should merge list item with with previous list item with higher indent as a block', () => { setModelData( model, modelList( [ '* a', - ' * []a', - ' b' + ' * b', + '* []c' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a', - ' []a', - ' b' + ' * b', + ' []c' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge indented list having block and indented list item with previous list item', () => { + it( 'should merge empty list item with with previous list item with higher indent as a block', () => { setModelData( model, modelList( [ '* a', - ' * []b', - ' c', - ' * d' + ' * b', + '* []' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a', - ' []b', - ' c', - ' * d' + ' * b', + ' []' ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); } ); - it( 'should merge indented empty list item with previous list item', () => { + it( 'should keep merged list item\'s children', () => { setModelData( model, modelList( [ '* a', - ' * []', - ' text' - ] ) ); + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + } ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + '* [', + '* ]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + // // ------------ + // '* [', + // '* a', + // '* ]b' + + // // ------------ + // '* []', + // '* b' + + // // ------------ WRONG + // '* []', + // ' b' + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther{id:001}' + ] ) ); + } ); + + it( 'should merge two list itemsx TODO', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* text[', + '* ]another' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]another' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* text[', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]ther' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]b', + ' * c{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]c', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]d' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]e' + ] ) ); + } ); + } ); + } ); + } ); + + describe( 'multi-block list item', () => { + describe( 'collapsed selection at the beginning of a list item', () => { + describe( 'item before is empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:001}', + ' c' + ] ) ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + } ); + + // TODO: fix ids???? + it( 'should merge list item with first block empty with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []', + ' a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' a' + ] ) ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a{id:001}', + ' b' + ] ) ); + } ); + + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ] ) ); + } ); + + it( 'should merge indented empty list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' text' + ] ) ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}', + ' b' + ] ) ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c' + ] ) ); + } ); + + it( 'should TODO', () => { + setModelData( model, modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* a{id:a}', + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a{id:a}', + ' []b', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + } ); + + it( 'should merge list item with first block empty with previous list item', () => { + setModelData( model, modelList( [ + '* a', + '* []', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' b' + ] ) ); + } ); + + it( 'should merge indented list item with with previous list item as blocks', () => { + setModelData( model, modelList( [ + '* a', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []a', + ' b' + ] ) ); + } ); + + it( 'should merge indented list having block and indented list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d' + ] ) ); + } ); + + it( 'should merge indented empty list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' text' + ] ) ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c', + ' d' + ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a', - ' []', - ' text' + ' * b', + ' []c', + ' d' ] ) ); + } ); + } ); + } ); - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + '* [', + '* ]', + ' ' + ] ) ); - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + view.document.fire( eventInfo, domEventData ); - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' ' + ] ) ); } ); - it( 'should merge list item with with previous indented empty list item', () => { + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { setModelData( model, modelList( [ + '* [', '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:004}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list itemxx', () => { + setModelData( model, modelList( [ + '* [', ' * b', + ' ]c', + ' * d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []c', - ' d' + ' * d{id:003}', + ' e' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge middle block with following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d{id:001}', + ' * e{id:003}', + ' f' + ] ) ); + } ); + + // TODO: Is the expected correct? + it( 'should delete items till the end of selection and merge following blocks', () => { + setModelData( model, modelList( [ + '* [{id:a}', + ' * b', + ' cd]', + ' * e{id:b}', + ' f', + ' s' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:a}', + ' * e{id:b}', + ' f', + ' s' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther{id:001}', + ' text' + ] ) ); + } ); + + // Not related to merge command + it( 'should merge two list items with selection in the middle', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:000}', + ' * c{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' ] ) ); view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', '* a', ' * b', - ' []c', - ' d' + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' ] ) ); + } ); - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); + // TODO: Is expected correct? + it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f' + ] ) ); - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + view.document.fire( eventInfo, domEventData ); - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' c', + ' * d{id:004}', + ' e', + ' f' + ] ) ); } ); } ); } ); } ); } ); - describe( 'non-collapsed selection', () => { - // TODO + describe( 'forward delete', () => { + it( 'xx', () => { + setModelData( model, modelList( [ + '* a[]', + '* b', + '* c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + '* c' + ] ) ); + } ); + + it( 'xxx', () => { + setModelData( model, modelList( [ + '* a[]', + '* b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]', + ' b', + ' c' + ] ) ); + } ); + + it( 'xxxx', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]', + ' b', + ' c' + ] ) ); + } ); + + it( 'xxxxx', () => { + setModelData( model, modelList( [ + '* a', + ' b[]', + '* c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]', + ' c', + ' d' + ] ) ); + } ); + + it( 'xxxxxx', () => { + setModelData( model, modelList( [ + '* a', + ' b[]', + ' * c', + '* b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]', + ' c', + '* b', + ' c' + ] ) ); + } ); + + it( 'xxxxxxx', () => { + setModelData( model, modelList( [ + '* a', + ' b[]', + ' * c', + '* b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]', + ' c', + '* b', + ' c' + ] ) ); + } ); + + it( 'xxxxxxxx', () => { + setModelData( model, modelList( [ + '* []', + ' b', + ' * c', + ' * b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' * b', + ' c' + ] ) ); + } ); } ); } ); } ); From b50aa1331e57f878c336d4fec5aecd3da41c6788 Mon Sep 17 00:00:00 2001 From: Andrzej Stanek Date: Tue, 18 Jan 2022 18:09:27 +0100 Subject: [PATCH 09/44] Add tests to stringifyList() --- .../ckeditor5-engine/src/dev-utils/model.js | 3 +- .../tests/documentlist/_utils-tests/utils.js | 424 ++++++++++++++++-- 2 files changed, 387 insertions(+), 40 deletions(-) diff --git a/packages/ckeditor5-engine/src/dev-utils/model.js b/packages/ckeditor5-engine/src/dev-utils/model.js index c52934d63ff..61b2e2abfb5 100644 --- a/packages/ckeditor5-engine/src/dev-utils/model.js +++ b/packages/ckeditor5-engine/src/dev-utils/model.js @@ -304,6 +304,7 @@ export function stringify( node, selectionOrPositionOrRange = null, markers = nu * @param {Object} [options={}] Additional configuration. * @param {Array} [options.selectionAttributes] A list of attributes which will be passed to the selection. * @param {Boolean} [options.lastRangeBackward=false] If set to `true`, the last range will be added as backward. + * @param {Boolean} [options.wrapSingleElement=false] If set to `true`, single model elements will be wrapped in DocumentFragment. * @param {module:engine/model/schema~SchemaContextDefinition} [options.context='$root'] The conversion context. * If not provided, the default `'$root'` will be used. * @returns {module:engine/model/element~Element|module:engine/model/text~Text| @@ -351,7 +352,7 @@ export function parse( data, schema, options = {} ) { mapper.bindElements( model, viewDocumentFragment.root ); // If root DocumentFragment contains only one element - return that element. - if ( model.childCount == 1 ) { + if ( model.childCount == 1 && !options.wrapSingleElement ) { model = model.getChild( 0 ); } diff --git a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js index 274377f356a..2616d811ff0 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js @@ -300,48 +300,394 @@ describe( 'stringifyList()', () => { model.schema.extend( '$container', { allowAttributes: [ 'listType', 'listIndent', 'listItemId' ] } ); } ); - it( 'flat list', () => { - const input = parseModel( - 'aaa' + - 'bbb', - model.schema - ); - - expect( stringifyList( input ) ).to.equal( [ - '* aaa', - '* bbb' - ].join( '\n' ) ); + describe( 'bulleted list', () => { + it( 'flat list', () => { + const input = parseModel( + 'aaa' + + 'bbb', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '* aaa', + '* bbb' + ].join( '\n' ) ); + } ); + + it( 'flat list with multi-block items', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '* aaa', + ' bbb', + '* ccc' + ].join( '\n' ) ); + } ); + + it( 'nested list with multi-block items', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '* aaa', + ' * bbb', + ' ccc' + ].join( '\n' ) ); + } ); + + it( 'nested list with many items', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '* aaa', + ' * bbb', + ' * ccc', + ' * ddd' + ].join( '\n' ) ); + } ); + + it( 'many indentations', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '* aaa', + ' * bbb', + ' * ccc', + ' * ddd' + ].join( '\n' ) ); + } ); + + it( 'many indentations with multiple blocks', () => { + const input = parseModel( + 'aaa' + + 'aaa' + + 'bbb' + + 'bbb' + + 'ccc' + + 'ccc' + + 'ddd' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* aaa', + ' aaa', + ' * bbb', + ' bbb', + ' * ccc', + ' ccc', + ' * ddd', + ' ddd' + ].join( '\n' ) ); + } ); + + it( 'nested multi-blocks item', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* aaa', + ' * bbb', + ' ccc' + ].join( '\n' ) ); + } ); + + it( 'nested multi-blocks item followed by a list item', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* aaa', + ' * bbb', + ' ccc', + '* ddd' + ].join( '\n' ) ); + } ); + + it( 'single list item', () => { + const input = parseModel( + 'a', + model.schema, + { wrapSingleElement: true } + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* a' + ].join( '\n' ) ); + } ); + + it( 'empty list item', () => { + const input = parseModel( + '', + model.schema, + { wrapSingleElement: true } + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* ' + ].join( '\n' ) ); + } ); } ); - it( 'flat list with multi-block items', () => { - const input = parseModel( - 'aaa' + - 'bbb' + - 'ccc', - model.schema - ); - - expect( stringifyList( input ) ).to.equal( [ - '* aaa', - ' bbb', - '* ccc' - ].join( '\n' ) ); + describe( 'numbered list', () => { + it( 'flat list', () => { + const input = parseModel( + 'aaa' + + 'bbb', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + '# bbb' + ].join( '\n' ) ); + } ); + + it( 'flat list with multi-block items', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' bbb', + '# ccc' + ].join( '\n' ) ); + } ); + + it( 'nested list with multi-block items', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' # bbb', + ' ccc' + ].join( '\n' ) ); + } ); + + it( 'nested list with many items', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' # bbb', + ' # ccc', + ' # ddd' + ].join( '\n' ) ); + } ); + + it( 'many indentations', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' # bbb', + ' # ccc', + ' # ddd' + ].join( '\n' ) ); + } ); + + it( 'many indentations with multiple blocks', () => { + const input = parseModel( + 'aaa' + + 'aaa' + + 'bbb' + + 'bbb' + + 'ccc' + + 'ccc' + + 'ddd' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' aaa', + ' # bbb', + ' bbb', + ' # ccc', + ' ccc', + ' # ddd', + ' ddd' + ].join( '\n' ) ); + } ); + + it( 'nested multi-blocks item', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' # bbb', + ' ccc' + ].join( '\n' ) ); + } ); + + it( 'nested multi-blocks item followed by a list item', () => { + const input = parseModel( + 'aaa' + + 'bbb' + + 'ccc' + + 'ddd', + model.schema + ); + + expect( stringifyList( input ) ).to.equal( [ + '# aaa', + ' # bbb', + ' ccc', + '# ddd' + ].join( '\n' ) ); + } ); + + it( 'single list item', () => { + const input = parseModel( + 'a', + model.schema, + { wrapSingleElement: true } + ); + + expect( stringifyList( input ) ).to.equal( [ + '# a' + ].join( '\n' ) ); + } ); + + it( 'empty list item', () => { + const input = parseModel( + '', + model.schema, + { wrapSingleElement: true } + ); + + expect( stringifyList( input ) ).to.equal( [ + '# ' + ].join( '\n' ) ); + } ); } ); - it( 'nested list with multi-block items', () => { - const input = parseModel( - 'aaa' + - 'bbb' + - 'ccc', - model.schema - ); - - expect( stringifyList( input ) ).to.equal( [ - '* aaa', - ' * bbb', - ' ccc' - ].join( '\n' ) ); + describe( 'mixed lists', () => { + it( 'bulleted and numbered list', () => { + const input = parseModel( + 'a' + + '0', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* a', + '# 0' + ].join( '\n' ) ); + } ); + + it( 'numbered list item with nested bulleted list item', () => { + const input = parseModel( + '0' + + 'a', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '# 0', + ' * a' + ].join( '\n' ) ); + } ); + + it( 'bulleted list item with nested numbered list item', () => { + const input = parseModel( + 'a' + + '0', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* a', + ' # 0' + ].join( '\n' ) ); + } ); + + it( 'numbered list with many blocks and nested bulleted list item', () => { + const input = parseModel( + '0' + + '1' + + 'a', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '# 0', + ' 1', + ' * a' + ].join( '\n' ) ); + } ); + + it( 'bulleted list with many blocks and nested numbered list item', () => { + const input = parseModel( + 'a' + + 'b' + + '0', + model.schema + ); + + expect( stringifyList( input ) ).to.equalMarkup( [ + '* a', + ' b', + ' # 0' + ].join( '\n' ) ); + } ); } ); - - // TODO } ); From f81916ae45c13cb926cfb77c9d86051674fcddbb Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 19 Jan 2022 14:54:12 +0100 Subject: [PATCH 10/44] Simplified DocumentListMergeCommand. --- .../documentlist/documentlistmergecommand.js | 26 +- .../src/documentlist/utils/model.js | 4 +- .../documentlistediting-integrations.js | 923 +++++++++++++++++- 3 files changed, 902 insertions(+), 51 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index b8f29fd5c08..f2958931989 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -9,7 +9,9 @@ import { Command } from 'ckeditor5/src/core'; import { - indentBlocks, isFirstBlockOfListItem, + getNestedListBlocks, + indentBlocks, + isFirstBlockOfListItem, mergeListItemBefore } from './utils/model'; import ListWalker from './utils/listwalker'; @@ -89,15 +91,18 @@ export default class DocumentListMergeCommand extends Command { const lastElementId = lastElement.getAttribute( 'listItemId' ); if ( firstIndent != lastIndent ) { - indentBlocks( lastElement, writer, { + const nestedLastElementBlocks = getNestedListBlocks( lastElement ); + + indentBlocks( [ lastElement, ...nestedLastElementBlocks ], writer, { indentBy: firstIndent - lastIndent, - expand: isFirstBlock ? 'forward' : false + + // If outdenting, the entire sub-tree that follows must be included. + expand: firstIndent < lastIndent } ); } if ( deleteContent ) { let sel = selection; - const wasSelectionCollapsed = sel.isCollapsed; if ( selection.isCollapsed ) { sel = writer.createSelection( writer.createRange( @@ -115,19 +120,8 @@ export default class DocumentListMergeCommand extends Command { // Check if the element after it was in the same list item and adjust it if needed. const nextSibling = lastElementAfterDelete.nextSibling; - if ( nextSibling && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { + if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ); - - // Note: Using cached selection state because deleteContent will collapse the selection. - // If last element was empty, it would land in the graveyard. - if ( !wasSelectionCollapsed && lastElement.root === firstElement.root ) { - sel = writer.createSelection( writer.createRange( - writer.createPositionAt( firstElement, 'end' ), - writer.createPositionAt( lastElement, 0 ) - ) ); - - model.deleteContent( sel, { doNotResetEntireContent: true } ); - } } } else { mergeListItemBefore( lastElement, firstElement, writer ); diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 35ff1aa407d..fa95acb04fb 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -162,6 +162,7 @@ export function isLastBlockOfListItem( listBlock ) { * @protected * @param {module:engine/model/element~Element|Array.} blocks The list of selected blocks. * @param {Object} [options] + * TODO: Looks like expand in all directions is only used here, no need for forward or backward. * @param {Boolean} [options.withNested=true] Whether should include nested list items. * @returns {Array.} */ @@ -243,7 +244,8 @@ export function mergeListItemBefore( listBlock, parentBlock, writer ) { * @param {module:engine/model/element~Element|Iterable.} blocks The block or iterable of blocks. * @param {module:engine/model/writer~Writer} writer The model writer. * @param {Object} [options] - * @param {Boolean} [options.expand=false] Whether should expand the list of blocks to include complete list items + * @param {Boolean} [options.expand=false] Whether should expand the list of blocks to include complete list items. + * TODO get rid of 'forward', looks like it is not used anywhere. * @param {Number} [options.indentBy=1] TODO * (all blocks of given list items). */ diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index f25bf23c69d..9ed129d2c1f 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -1789,8 +1789,8 @@ describe( 'DocumentListEditing integrations', () => { describe( 'backspace key handling', () => { const changedBlocks = []; let domEventData, mergeCommand, splitAfterCommand, indentCommand, - eventInfo; - // mergeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; + eventInfo, + mergeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; beforeEach( () => { eventInfo = new BubblingEventInfo( view.document, 'delete' ); @@ -1806,9 +1806,9 @@ describe( 'DocumentListEditing integrations', () => { indentCommand = editor.commands.get( 'outdentList' ); mergeCommand = editor.commands.get( 'mergeListItemBackward' ); - // splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); - // outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); - // mergeCommandExecuteSpy = sinon.spy( mergeCommand, 'execute' ); + splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); + outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); + mergeCommandExecuteSpy = sinon.spy( mergeCommand, 'execute' ); changedBlocks.length = 0; @@ -1826,6 +1826,836 @@ describe( 'DocumentListEditing integrations', () => { } ); describe( 'backward delete', () => { + describe( 'extra tests', () => { + describe( 'collapsed selection', () => { + describe( 'at the beginning of a list item', () => { + describe( 'single block list item', () => { + describe( 'item before is empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* ', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b {id:001}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + // Default behaviour of backspace? + it( 'should merge empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a{id:001}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should keep merged list item\'s children', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + } ); + + describe( 'multi-block list item', () => { + describe( 'item before is empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:001}', + ' c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:b}', + ' c', + ' * d{id:d}', + ' e', + ' * f{id:f}', + ' * g{id:g}', + ' h', + ' * i{id:i}', + ' * j{id:j}', + ' k', + ' l' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with first block empty with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []', + ' a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' a' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should TODO', () => { + setModelData( model, modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with first block empty with previous list item', () => { + setModelData( model, modelList( [ + '* a', + '* []', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous list item as blocks', () => { + setModelData( model, modelList( [ + '* a', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []a', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list having block and indented list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c', + ' d' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + } ); + } ); + } ); + } ); + } ); + describe( 'single block list item', () => { describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { @@ -2281,23 +3111,11 @@ describe( 'DocumentListEditing integrations', () => { ' * ]b' ] ) ); - // // ------------ - // '* [', - // '* a', - // '* ]b' - - // // ------------ - // '* []', - // '* b' - - // // ------------ WRONG - // '* []', - // ' b' - view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b' + '* []', + '* b {id:002}' ] ) ); } ); @@ -2344,7 +3162,8 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d' + '* []', + '* d {id:003}' ] ) ); } ); @@ -2428,7 +3247,8 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); // output is okay, fix expect expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]b', + '* text[]', + '* b {id:002}', ' * c{id:003}' ] ) ); } ); @@ -2477,7 +3297,8 @@ describe( 'DocumentListEditing integrations', () => { // output is okay, fix expect expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]d' + '* text[]', + '* d {id:003}' ] ) ); } ); @@ -2803,6 +3624,36 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); + describe( 'collapsed selection in the middle of the list item', () => { + it( 'TODO', () => { + setModelData( model, modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ] ) ); + } ); + } ); + describe( 'non-collapsed selection starting in first block of a list item', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { @@ -2856,7 +3707,8 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b' + '* []', + '* b {id:002}' ] ) ); } ); @@ -2903,7 +3755,8 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d' + '* []', + '* d {id:003}' ] ) ); } ); @@ -2950,8 +3803,9 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c', - ' * d{id:003}', + '* []', + '* c', + ' * d {id:003}', ' e' ] ) ); } ); @@ -2975,7 +3829,7 @@ describe( 'DocumentListEditing integrations', () => { } ); // TODO: Is the expected correct? - it( 'should delete items till the end of selection and merge following blocks', () => { + it.skip( 'should delete items till the end of selection and merge following blocks', () => { setModelData( model, modelList( [ '* [{id:a}', ' * b', @@ -3061,10 +3915,11 @@ describe( 'DocumentListEditing integrations', () => { ] ) ); view.document.fire( eventInfo, domEventData ); - // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:000}', - ' * c{id:003}' + '* []', + '* b {id:002}', + ' * c {id:003}' ] ) ); } ); @@ -3110,9 +3965,9 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); - // output is okay, fix expect expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d' + '* []', + '* d {id:003}' ] ) ); } ); @@ -3132,7 +3987,7 @@ describe( 'DocumentListEditing integrations', () => { } ); // TODO: Is expected correct? - it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { + it.skip( 'should delete all items and text till the end of selection and adjust orphan elements', () => { setModelData( model, modelList( [ '* [', '* a', @@ -3158,7 +4013,7 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); - describe( 'forward delete', () => { + describe.skip( 'forward delete', () => { it( 'xx', () => { setModelData( model, modelList( [ '* a[]', From 79a5a6231c4bedb8ed472fc0f53378cef1601891 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 19 Jan 2022 15:55:57 +0100 Subject: [PATCH 11/44] Tests: Settled on expected output in corner cases when merging list items. --- .../documentlistediting-integrations.js | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index 9ed129d2c1f..7e533dc380e 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -3828,13 +3828,12 @@ describe( 'DocumentListEditing integrations', () => { ] ) ); } ); - // TODO: Is the expected correct? - it.skip( 'should delete items till the end of selection and merge following blocks', () => { + it( 'should delete items till the end of selection and merge following blocks', () => { setModelData( model, modelList( [ - '* [{id:a}', + '* [', ' * b', ' cd]', - ' * e{id:b}', + ' * e', ' f', ' s' ] ) ); @@ -3842,10 +3841,10 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:a}', - ' * e{id:b}', + '* []', + ' * e {id:003}', ' f', - ' s' + '* s' ] ) ); } ); } ); @@ -3986,8 +3985,7 @@ describe( 'DocumentListEditing integrations', () => { ] ) ); } ); - // TODO: Is expected correct? - it.skip( 'should delete all items and text till the end of selection and adjust orphan elements', () => { + it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { setModelData( model, modelList( [ '* [', '* a', @@ -3995,7 +3993,8 @@ describe( 'DocumentListEditing integrations', () => { ' c', ' * d', ' e', - ' f' + ' f', + ' g' ] ) ); view.document.fire( eventInfo, domEventData ); @@ -4003,9 +4002,10 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []', ' c', - ' * d{id:004}', + ' * d {id:004}', ' e', - ' f' + '* f', + ' g' ] ) ); } ); } ); From 3b6193871c3eb0dbe8f7ca2a45935597c18749f0 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 19 Jan 2022 16:18:19 +0100 Subject: [PATCH 12/44] Improvements to backspace handling in lists. --- .../src/documentlist/documentlistediting.js | 17 ++++++++++++++++- .../documentlistediting-integrations.js | 16 ++++++++++++++-- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 6e52f26c958..b6cc4ee4ee6 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -117,7 +117,14 @@ export default class DocumentListEditing extends Plugin { if ( data.direction == 'backward' && firstPosition.isAtStart ) { const previousSibling = positionParent.previousSibling; - const previousSiblingIsSameListItem = isSingleListItem( [ positionParent, previousSibling ] ); + let previousSiblingIsSameListItem; + + // There's no previous sibling when the position parent is the first item of the root. + if ( previousSibling ) { + previousSiblingIsSameListItem = isSingleListItem( [ positionParent, previousSibling ] ); + } else { + previousSiblingIsSameListItem = true; + } // Merge block with previous one (on the block level or on the content level). if ( previousSibling && previousSibling.hasAttribute( 'listItemId' ) ) { @@ -141,6 +148,14 @@ export default class DocumentListEditing extends Plugin { throw new Error( 'not yet' ); } } else { + // TODO: What if not in a list? + // TODO: What if start only in a list? + // TODO: What if end only in a list? + // TODO (tests): + // li[st + // some-non-list + // anothe]rlist + if ( data.direction == 'backward' ) { editor.execute( 'mergeListItemBackward', { deleteContent: true diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index 7e533dc380e..bb531a776c5 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -2659,6 +2659,18 @@ describe( 'DocumentListEditing integrations', () => { describe( 'single block list item', () => { describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { + it( 'should remove list when in empty only element of a list', () => { + setModelData( model, modelList( [ + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + } ); + it( 'should merge non empty list item with with previous list item as a block', () => { setModelData( model, modelList( [ '* ', @@ -3844,7 +3856,7 @@ describe( 'DocumentListEditing integrations', () => { '* []', ' * e {id:003}', ' f', - '* s' + '* s {id:001}' ] ) ); } ); } ); @@ -4004,7 +4016,7 @@ describe( 'DocumentListEditing integrations', () => { ' c', ' * d {id:004}', ' e', - '* f', + '* f {id:001}', ' g' ] ) ); } ); From e78e5182b4e1fe21f3c195d2c23569709e96cb7b Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 19 Jan 2022 16:33:23 +0100 Subject: [PATCH 13/44] Started forward delete integration in document lists. --- .../src/documentlist/documentlistediting.js | 11 +++++-- .../documentlistediting-integrations.js | 31 +++++++++++++------ 2 files changed, 31 insertions(+), 11 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index b6cc4ee4ee6..d4887877f33 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -144,8 +144,15 @@ export default class DocumentListEditing extends Plugin { data.preventDefault(); evt.stop(); } else if ( data.direction == 'forward' && firstPosition.isAtEnd ) { - // TODO - throw new Error( 'not yet' ); + const nextSibling = positionParent.nextSibling; + + if ( !isLastBlockOfListItem( nextSibling ) ) { + editor.execute( 'mergeListItemForward', { + } ); + + data.preventDefault(); + evt.stop(); + } } } else { // TODO: What if not in a list? diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index bb531a776c5..1a9fae59d83 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -1794,13 +1794,6 @@ describe( 'DocumentListEditing integrations', () => { beforeEach( () => { eventInfo = new BubblingEventInfo( view.document, 'delete' ); - domEventData = new DomEventData( view, { - preventDefault: sinon.spy() - }, { - direction: 'backward', - unit: 'codePoint', - sequence: 1 - } ); splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); indentCommand = editor.commands.get( 'outdentList' ); @@ -1826,6 +1819,16 @@ describe( 'DocumentListEditing integrations', () => { } ); describe( 'backward delete', () => { + beforeEach( () => { + domEventData = new DomEventData( view, { + preventDefault: sinon.spy() + }, { + direction: 'backward', + unit: 'codePoint', + sequence: 1 + } ); + } ); + describe( 'extra tests', () => { describe( 'collapsed selection', () => { describe( 'at the beginning of a list item', () => { @@ -4025,7 +4028,17 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); - describe.skip( 'forward delete', () => { + describe( 'forward delete', () => { + beforeEach( () => { + domEventData = new DomEventData( view, { + preventDefault: sinon.spy() + }, { + direction: 'forward', + unit: 'codePoint', + sequence: 1 + } ); + } ); + it( 'xx', () => { setModelData( model, modelList( [ '* a[]', @@ -4037,7 +4050,7 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* a[]b', - '* c' + '* c {id:002}' ] ) ); } ); From 96064aee78d02183d6b233a74036c5654b60ca7f Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Thu, 20 Jan 2022 18:24:40 +0100 Subject: [PATCH 14/44] Support for forward delete. --- .../src/documentlist/documentlistediting.js | 79 ++++++++----------- .../documentlist/documentlistmergecommand.js | 25 ++++-- 2 files changed, 49 insertions(+), 55 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index d4887877f33..41176158ec8 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -105,56 +105,46 @@ export default class DocumentListEditing extends Plugin { const selection = editor.model.document.selection; editor.model.change( () => { - if ( selection.isCollapsed ) { + if ( selection.isCollapsed && data.direction == 'backward' ) { const firstPosition = selection.getFirstPosition(); + + // TODO what about different list types? + + if ( !firstPosition.isAtStart ) { + return; + } + const positionParent = firstPosition.parent; if ( !positionParent.hasAttribute( 'listItemId' ) ) { return; } - // TODO what about different list types? - - if ( data.direction == 'backward' && firstPosition.isAtStart ) { - const previousSibling = positionParent.previousSibling; - let previousSiblingIsSameListItem; + const previousSibling = positionParent.previousSibling; + // Merge block with previous one (on the block level or on the content level). + if ( previousSibling && previousSibling.hasAttribute( 'listItemId' ) ) { // There's no previous sibling when the position parent is the first item of the root. - if ( previousSibling ) { - previousSiblingIsSameListItem = isSingleListItem( [ positionParent, previousSibling ] ); - } else { - previousSiblingIsSameListItem = true; - } - - // Merge block with previous one (on the block level or on the content level). - if ( previousSibling && previousSibling.hasAttribute( 'listItemId' ) ) { - editor.execute( 'mergeListItemBackward', { - deleteContent: previousSibling.isEmpty || previousSiblingIsSameListItem - } ); - } - // Outdent the first block of a first list item. - else { - if ( !isLastBlockOfListItem( positionParent ) ) { - editor.execute( 'splitListItemAfter' ); - } + const isInsideSingleListItem = isSingleListItem( [ positionParent, previousSibling ] ); - editor.execute( 'outdentList' ); + editor.execute( 'mergeListItemBackward', { + deleteContent: previousSibling.isEmpty || isInsideSingleListItem + } ); + } + // Outdent the first block of a first list item. + else { + if ( !isLastBlockOfListItem( positionParent ) ) { + editor.execute( 'splitListItemAfter' ); } - data.preventDefault(); - evt.stop(); - } else if ( data.direction == 'forward' && firstPosition.isAtEnd ) { - const nextSibling = positionParent.nextSibling; - - if ( !isLastBlockOfListItem( nextSibling ) ) { - editor.execute( 'mergeListItemForward', { - } ); - - data.preventDefault(); - evt.stop(); - } + editor.execute( 'outdentList' ); } - } else { + + data.preventDefault(); + evt.stop(); + } + // Non-collapsed selection or forward delete. + else { // TODO: What if not in a list? // TODO: What if start only in a list? // TODO: What if end only in a list? @@ -163,17 +153,12 @@ export default class DocumentListEditing extends Plugin { // some-non-list // anothe]rlist - if ( data.direction == 'backward' ) { - editor.execute( 'mergeListItemBackward', { - deleteContent: true - } ); + editor.execute( 'mergeListItemForward', { + deleteContent: true + } ); - data.preventDefault(); - evt.stop(); - } else { - // TODO - throw new Error( 'not yet' ); - } + data.preventDefault(); + evt.stop(); } } ); }, { context: 'li' } ); diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index f2958931989..d7cb54dd6fa 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -65,25 +65,32 @@ export default class DocumentListMergeCommand extends Command { let firstElement, lastElement; // TODO what about different list types? - // TODO handle non-collapsed selection - if ( this._direction == 'backward' ) { - if ( selection.isCollapsed ) { + if ( selection.isCollapsed ) { + if ( this._direction == 'backward' ) { lastElement = anchorElement; if ( isFirstBlock && !deleteContent ) { + // For the "c" as an anchorElement: + // * a + // * b + // * [c] <-- this block should be merged with "a" + // It should find "a" element to merge with: + // * a + // * b + // c firstElement = ListWalker.first( anchorElement, { sameIndent: true, lowerIndent: true } ); } else { firstElement = anchorElement.previousSibling; } } else { - firstElement = selection.getFirstPosition().parent; - lastElement = selection.getLastPosition().parent; + // In case of the forward merge there is no case as above, just merge with next sibling. + firstElement = anchorElement; + lastElement = anchorElement.nextSibling; } } else { - // TODO - firstElement = anchorElement; - lastElement = anchorElement.nextSibling; + firstElement = selection.getFirstPosition().parent; + lastElement = selection.getLastPosition().parent; } const firstIndent = firstElement.getAttribute( 'listIndent' ); @@ -162,6 +169,8 @@ export default class DocumentListMergeCommand extends Command { const firstPosition = selection.getFirstPosition(); const firstPositionParent = firstPosition.parent; + // TODO refactor this; it does not depend on where exactly in the list block the selection is + let firstNode; if ( selection.isCollapsed ) { From 8237e50bcbec8ff3232df8c5508feced00ab1319 Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Thu, 20 Jan 2022 19:12:49 +0100 Subject: [PATCH 15/44] WiP. --- .../ckeditor5-list/src/documentlist/documentlistmergecommand.js | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index d7cb54dd6fa..d85bab9a36a 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -112,6 +112,7 @@ export default class DocumentListMergeCommand extends Command { let sel = selection; if ( selection.isCollapsed ) { + // TODO what if one of blocks is an object (for example a table or block image)? sel = writer.createSelection( writer.createRange( writer.createPositionAt( firstElement, 'end' ), writer.createPositionAt( lastElement, 0 ) From 32fd2953d29e54af78594b5f7c9bd441f658cbcb Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Mon, 24 Jan 2022 15:10:55 +0100 Subject: [PATCH 16/44] WiP. --- .../src/documentlist/documentlistediting.js | 61 ++++++++++++------- .../documentlist/documentlistmergecommand.js | 22 +++---- 2 files changed, 51 insertions(+), 32 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 41176158ec8..bb7bb68cead 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -35,7 +35,7 @@ import { isLastBlockOfListItem, isSingleListItem } from './utils/model'; -import { iterateSiblingListBlocks } from './utils/listwalker'; +import ListWalker, { iterateSiblingListBlocks } from './utils/listwalker'; import '../../theme/documentlist.css'; @@ -108,8 +108,6 @@ export default class DocumentListEditing extends Plugin { if ( selection.isCollapsed && data.direction == 'backward' ) { const firstPosition = selection.getFirstPosition(); - // TODO what about different list types? - if ( !firstPosition.isAtStart ) { return; } @@ -120,38 +118,59 @@ export default class DocumentListEditing extends Plugin { return; } - const previousSibling = positionParent.previousSibling; - - // Merge block with previous one (on the block level or on the content level). - if ( previousSibling && previousSibling.hasAttribute( 'listItemId' ) ) { - // There's no previous sibling when the position parent is the first item of the root. - const isInsideSingleListItem = isSingleListItem( [ positionParent, previousSibling ] ); + const previousBlock = ListWalker.first( positionParent, { sameIndent: true, sameItemType: true } ); - editor.execute( 'mergeListItemBackward', { - deleteContent: previousSibling.isEmpty || isInsideSingleListItem - } ); - } // Outdent the first block of a first list item. - else { + if ( !previousBlock ) { if ( !isLastBlockOfListItem( positionParent ) ) { editor.execute( 'splitListItemAfter' ); } editor.execute( 'outdentList' ); } + // Merge block with previous one (on the block level or on the content level). + else { + const previousSibling = positionParent.previousSibling; + const isInsideSingleListItem = isSingleListItem( [ positionParent, previousSibling ] ); + + if ( model.schema.isObject( previousSibling ) ) { + if ( isInsideSingleListItem ) { + return; + } + + editor.execute( 'mergeListItemBackward', { + deleteContent: false + } ); + } else { + editor.execute( 'mergeListItemBackward', { + deleteContent: previousSibling.isEmpty || isInsideSingleListItem + } ); + } + } data.preventDefault(); evt.stop(); } // Non-collapsed selection or forward delete. else { - // TODO: What if not in a list? - // TODO: What if start only in a list? - // TODO: What if end only in a list? - // TODO (tests): - // li[st - // some-non-list - // anothe]rlist + const lastPosition = selection.getLastPosition(); + const positionParent = lastPosition.parent; + + // Collapsed selection should trigger forward merging only if at the end of a block. + if ( selection.isCollapsed && !lastPosition.isAtEnd ) { + return; + } + + // The list bocks merging is required only if the selection ends in the list item + // (in case of fixing the indents of following list items). + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return; + } + + // TODO let the widget handler do its stuff + if ( model.schema.isObject( positionParent.nextSibling ) ) { + return; + } editor.execute( 'mergeListItemForward', { deleteContent: true diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index d85bab9a36a..bfc4cbcf7dd 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -60,15 +60,14 @@ export default class DocumentListMergeCommand extends Command { const selection = model.document.selection; model.change( writer => { - const anchorElement = selection.getFirstPosition().parent; - const isFirstBlock = isFirstBlockOfListItem( anchorElement ); let firstElement, lastElement; - // TODO what about different list types? - if ( selection.isCollapsed ) { + const positionParent = selection.getFirstPosition().parent; + const isFirstBlock = isFirstBlockOfListItem( positionParent ); + if ( this._direction == 'backward' ) { - lastElement = anchorElement; + lastElement = positionParent; if ( isFirstBlock && !deleteContent ) { // For the "c" as an anchorElement: @@ -79,21 +78,21 @@ export default class DocumentListMergeCommand extends Command { // * a // * b // c - firstElement = ListWalker.first( anchorElement, { sameIndent: true, lowerIndent: true } ); + firstElement = ListWalker.first( positionParent, { sameIndent: true, lowerIndent: true } ); } else { - firstElement = anchorElement.previousSibling; + firstElement = positionParent.previousSibling; } } else { // In case of the forward merge there is no case as above, just merge with next sibling. - firstElement = anchorElement; - lastElement = anchorElement.nextSibling; + firstElement = positionParent; + lastElement = positionParent.nextSibling; } } else { firstElement = selection.getFirstPosition().parent; lastElement = selection.getLastPosition().parent; } - const firstIndent = firstElement.getAttribute( 'listIndent' ); + const firstIndent = firstElement.getAttribute( 'listIndent' ) || 0; const lastIndent = lastElement.getAttribute( 'listIndent' ); const lastElementId = lastElement.getAttribute( 'listItemId' ); @@ -119,7 +118,8 @@ export default class DocumentListMergeCommand extends Command { ) ); } - model.deleteContent( sel, { doNotResetEntireContent: true } ); + // Delete selected content. Replace entire content only for non-collapsed selection. + model.deleteContent( sel, { doNotResetEntireContent: selection.isCollapsed } ); // Get the last "touched" element after deleteContent call (can't use the lastElement because // it could get merged into the firstElement while deleting content). From 9c3f0a08e2f0d17e9476599c1ef4894d0634b2a5 Mon Sep 17 00:00:00 2001 From: Andrzej Stanek Date: Mon, 24 Jan 2022 23:54:54 +0100 Subject: [PATCH 17/44] Add tests to document list editing integrations --- .../src/documentlist/documentlistediting.js | 8 +- .../documentlistediting-integrations.js | 3133 +++++++++++------ .../documentlist/documentlistmergecommand.js | 26 +- 3 files changed, 2147 insertions(+), 1020 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index bb7bb68cead..2257d7b822f 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -121,7 +121,7 @@ export default class DocumentListEditing extends Plugin { const previousBlock = ListWalker.first( positionParent, { sameIndent: true, sameItemType: true } ); // Outdent the first block of a first list item. - if ( !previousBlock ) { + if ( !previousBlock && positionParent.getAttribute( 'listIndent' ) === 0 ) { if ( !isLastBlockOfListItem( positionParent ) ) { editor.execute( 'splitListItemAfter' ); } @@ -168,9 +168,9 @@ export default class DocumentListEditing extends Plugin { } // TODO let the widget handler do its stuff - if ( model.schema.isObject( positionParent.nextSibling ) ) { - return; - } + // if ( model.schema.isObject( positionParent.nextSibling ) ) { + // return; + // } editor.execute( 'mergeListItemForward', { deleteContent: true diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js index 1a9fae59d83..b540708fbab 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js @@ -59,7 +59,7 @@ describe( 'DocumentListEditing integrations', () => { editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. - sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => {} ); + sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); stubUid(); } ); @@ -84,13 +84,13 @@ describe( 'DocumentListEditing integrations', () => { expect( data ).to.equal( '
    ' + - '
  • ' + - '

    B1

    ' + - '

    B2

    ' + - '
      ' + - '
    • C1
      • ' + - '
    ' + - '
    • ' + + '
  • ' + + '

    B1

    ' + + '

    B2

    ' + + '
      ' + + '
    • C1
      • ' + + '
    ' + + '
    • ' + '
' ); } ); @@ -110,10 +110,10 @@ describe( 'DocumentListEditing integrations', () => { expect( data ).to.equal( '
    ' + - '
  • ' + - '

    C1

    ' + - '

    C2

    ' + - '
    • ' + + '
  • ' + + '

    C1

    ' + + '

    C2

    ' + + '
    • ' + '
' ); } ); @@ -1786,22 +1786,24 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); - describe( 'backspace key handling', () => { + describe( 'delete keys handling', () => { const changedBlocks = []; - let domEventData, mergeCommand, splitAfterCommand, indentCommand, + let domEventData, mergeBackwardCommand, mergeForwardCommand, splitAfterCommand, indentCommand, eventInfo, - mergeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; + mergeBackwardCommandExecuteSpy, mergeForwardCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; beforeEach( () => { eventInfo = new BubblingEventInfo( view.document, 'delete' ); splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); indentCommand = editor.commands.get( 'outdentList' ); - mergeCommand = editor.commands.get( 'mergeListItemBackward' ); + mergeBackwardCommand = editor.commands.get( 'mergeListItemBackward' ); + mergeForwardCommand = editor.commands.get( 'mergeListItemForward' ); splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); - mergeCommandExecuteSpy = sinon.spy( mergeCommand, 'execute' ); + mergeBackwardCommandExecuteSpy = sinon.spy( mergeBackwardCommand, 'execute' ); + mergeForwardCommandExecuteSpy = sinon.spy( mergeForwardCommand, 'execute' ); changedBlocks.length = 0; @@ -1813,7 +1815,11 @@ describe( 'DocumentListEditing integrations', () => { changedBlocks.push( ...data ); } ); - mergeCommand.on( 'afterExecute', ( evt, data ) => { + mergeBackwardCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + mergeForwardCommand.on( 'afterExecute', ( evt, data ) => { changedBlocks.push( ...data ); } ); } ); @@ -1829,836 +1835,6 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); - describe( 'extra tests', () => { - describe( 'collapsed selection', () => { - describe( 'at the beginning of a list item', () => { - describe( 'single block list item', () => { - describe( 'item before is empty', () => { - it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b {id:001}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - // Default behaviour of backspace? - it( 'should merge empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - } ); - - describe( 'item before is not empty', () => { - it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented empty list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should keep merged list item\'s children', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - } ); - } ); - - describe( 'multi-block list item', () => { - describe( 'item before is empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* ', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge with previous list item and keep complex blocks intact', () => { - setModelData( model, modelList( [ - '* ', - '* []b{id:b}', - ' c', - ' * d{id:d}', - ' e', - ' * f{id:f}', - ' * g{id:g}', - ' h', - ' * i{id:i}', - ' * j{id:j}', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:b}', - ' c', - ' * d{id:d}', - ' e', - ' * f{id:f}', - ' * g{id:g}', - ' h', - ' * i{id:i}', - ' * j{id:j}', - ' k', - ' l' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with first block empty with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []', - ' a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' a' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b', - ' * c {id:003}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented empty list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - } ); - - describe( 'item before is not empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* a', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should TODO', () => { - setModelData( model, modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge with previous list item and keep complex blocks intact', () => { - setModelData( model, modelList( [ - '* a', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with first block empty with previous list item', () => { - setModelData( model, modelList( [ - '* a', - '* []', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list item with with previous list item as blocks', () => { - setModelData( model, modelList( [ - '* a', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []a', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list having block and indented list item with previous list item', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented empty list item with previous list item', () => { - setModelData( model, modelList( [ - '* a', - ' * []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c', - ' d' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - } ); - } ); - } ); - } ); - } ); - describe( 'single block list item', () => { describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { @@ -2683,11 +1859,17 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}' + '* []b {id:001}' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); - // Default behaviour of backspace? it( 'should merge empty list item with with previous empty list item', () => { setModelData( model, modelList( [ '* ', @@ -2699,6 +1881,13 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge indented list item with with previous empty list item', () => { @@ -2710,8 +1899,15 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}' + '* []a {id:001}' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge indented empty list item with with previous empty list item', () => { @@ -2725,6 +1921,13 @@ describe( 'DocumentListEditing integrations', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( [ '* []' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge list item with with previous indented empty list item', () => { @@ -2740,6 +1943,13 @@ describe( 'DocumentListEditing integrations', () => { '* ', ' * []a{id:002}' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge empty list item with with previous indented empty list item', () => { @@ -2755,6 +1965,13 @@ describe( 'DocumentListEditing integrations', () => { '* ', ' * []' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); } ); @@ -2771,6 +1988,13 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []b' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge empty list item with with previous list item as a block', () => { @@ -2785,6 +2009,13 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge indented list item with with parent list item as a block', () => { @@ -2799,6 +2030,13 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []b' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge indented empty list item with with parent list item as a block', () => { @@ -2813,6 +2051,13 @@ describe( 'DocumentListEditing integrations', () => { '* a', ' []' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge list item with with previous list item with higher indent as a block', () => { @@ -2829,6 +2074,13 @@ describe( 'DocumentListEditing integrations', () => { ' * b', ' []c' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge empty list item with with previous list item with higher indent as a block', () => { @@ -2845,6 +2097,13 @@ describe( 'DocumentListEditing integrations', () => { ' * b', ' []' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should keep merged list item\'s children', () => { @@ -2871,6 +2130,13 @@ describe( 'DocumentListEditing integrations', () => { ' * g', ' h' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); } ); } ); @@ -2913,7 +2179,7 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}' + '* []a {id:001}' ] ) ); } ); @@ -3082,6 +2348,7 @@ describe( 'DocumentListEditing integrations', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { setModelData( model, modelList( [ + 'a', '* [', '* ]' ] ) ); @@ -3089,6 +2356,7 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a', '* []' ] ) ); } ); @@ -3212,7 +2480,7 @@ describe( 'DocumentListEditing integrations', () => { ] ) ); } ); - it( 'should merge two list itemsx TODO', () => { + it( 'should merge two list items if selection is in the middle', () => { setModelData( model, modelList( [ '* te[xt', '* ano]ther' @@ -3351,20 +2619,27 @@ describe( 'DocumentListEditing integrations', () => { '* []b{id:001}', ' c' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); - it( 'should merge with previous list item and keep complex blocks intact', () => { + it.skip( 'should merge with previous list item and keep complex blocks intact ', () => { setModelData( model, modelList( [ '* ', - '* []b{id:b}', + '* []b', ' c', - ' * d{id:d}', + ' * d', ' e', - ' * f{id:f}', - ' * g{id:g}', + ' * f', + ' * g', ' h', - ' * i{id:i}', - ' * j{id:j}', + ' * i', + ' * j', ' k', ' l' ] ) ); @@ -3372,21 +2647,31 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:b}', + '* []b', ' c', - ' * d{id:d}', + ' * d', ' e', - ' * f{id:f}', - ' * g{id:g}', + ' * f', + ' * g', ' h', - ' * i{id:i}', - ' * j{id:j}', + ' * i', + ' * j', ' k', ' l' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); - // TODO: fix ids???? it( 'should merge list item with first block empty with previous empty list item', () => { setModelData( model, modelList( [ '* ', @@ -3400,6 +2685,17 @@ describe( 'DocumentListEditing integrations', () => { '* []', ' a' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge indented list item with with previous empty list item', () => { @@ -3412,9 +2708,20 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}', + '* []a {id:001}', ' b' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge indented list having block and indented list item with previous empty list item', () => { @@ -3432,6 +2739,17 @@ describe( 'DocumentListEditing integrations', () => { ' b', ' * c {id:003}' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge indented empty list item with previous empty list item', () => { @@ -3447,6 +2765,17 @@ describe( 'DocumentListEditing integrations', () => { '* []', ' text' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge list item with with previous indented empty list item', () => { @@ -3464,6 +2793,13 @@ describe( 'DocumentListEditing integrations', () => { ' * []a{id:002}', ' b' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge empty list item with with previous indented empty list item', () => { @@ -3481,6 +2817,13 @@ describe( 'DocumentListEditing integrations', () => { ' * []', ' text' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); } ); @@ -3499,9 +2842,20 @@ describe( 'DocumentListEditing integrations', () => { ' []b', ' c' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); - it( 'should TODO', () => { + it( 'should merge block to a previous list item', () => { setModelData( model, modelList( [ '* b', ' * c', @@ -3517,20 +2871,31 @@ describe( 'DocumentListEditing integrations', () => { ' []d', ' e' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge with previous list item and keep complex blocks intact', () => { setModelData( model, modelList( [ - '* a{id:a}', - '* []b{id:b}', + '* a', + '* []b', ' c', - ' * d{id:d}', + ' * d', ' e', - ' * f{id:f}', - ' * g{id:g}', + ' * f', + ' * g', ' h', - ' * i{id:i}', - ' * j{id:j}', + ' * i', + ' * j', ' k', ' l' ] ) ); @@ -3538,19 +2903,30 @@ describe( 'DocumentListEditing integrations', () => { view.document.fire( eventInfo, domEventData ); expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a{id:a}', + '* a', ' []b', ' c', - ' * d{id:d}', + ' * d', ' e', - ' * f{id:f}', - ' * g{id:g}', + ' * f', + ' * g', ' h', - ' * i{id:i}', - ' * j{id:j}', + ' * i', + ' * j', ' k', ' l' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge list item with first block empty with previous list item', () => { @@ -3567,6 +2943,17 @@ describe( 'DocumentListEditing integrations', () => { ' []', ' b' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge indented list item with with previous list item as blocks', () => { @@ -3583,6 +2970,17 @@ describe( 'DocumentListEditing integrations', () => { ' []a', ' b' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); } ); it( 'should merge indented list having block and indented list item with previous list item', () => { @@ -3601,6 +2999,13 @@ describe( 'DocumentListEditing integrations', () => { ' c', ' * d' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge indented empty list item with previous list item', () => { @@ -3617,6 +3022,13 @@ describe( 'DocumentListEditing integrations', () => { ' []', ' text' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); it( 'should merge list item with with previous indented empty list item', () => { @@ -3635,12 +3047,19 @@ describe( 'DocumentListEditing integrations', () => { ' []c', ' d' ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; } ); } ); } ); describe( 'collapsed selection in the middle of the list item', () => { - it( 'TODO', () => { + it( 'should merge block to a previous list item', () => { setModelData( model, modelList( [ '* A', ' * B', @@ -4026,141 +3445,1849 @@ describe( 'DocumentListEditing integrations', () => { } ); } ); } ); - } ); - describe( 'forward delete', () => { - beforeEach( () => { - domEventData = new DomEventData( view, { - preventDefault: sinon.spy() - }, { - direction: 'forward', - unit: 'codePoint', - sequence: 1 + describe( 'selection outside list', () => { + describe( 'collapsed selection', () => { + it( 'no list editing commands should be executed outside list (empty paragraph)', () => { + setModelData( model, + '[]' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + '[]' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed outside list (selection at the beginning of text)', () => { + setModelData( model, + '[]text' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + '[]text' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed outside list (selection at the end of text)', () => { + setModelData( model, + 'text[]' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + 'tex[]' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed outside list (selection in the middle of text)', () => { + setModelData( model, + 'te[]xt' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + 't[]xt' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed next to a list', () => { + setModelData( model, modelList( [ + '1[]', + '* 2' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]', + '* 2' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when merging two lists', () => { + setModelData( model, modelList( [ + '* 1', + '[]2', + '* 3' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* 1[]2', + '* 3 {id:002}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when merging two lists - one nested', () => { + setModelData( model, modelList( [ + '* 1', + '[]2', + '* 3', + ' * 4' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* 1[]2', + '* 3 {id:002}', + ' * 4 {id:003}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'empty list should be deleted', () => { + setModelData( model, modelList( [ + '* ', + '[]2', + '* 3' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]2', + '* 3 {id:002}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); } ); - } ); - it( 'xx', () => { - setModelData( model, modelList( [ - '* a[]', - '* b', - '* c' - ] ) ); + describe( 'non-collapsed selection', () => { + describe( 'outside list', () => { + it( 'no list editing commands should be executed', () => { + setModelData( model, modelList( [ + 't[ex]t' + ] ) ); - view.document.fire( eventInfo, domEventData ); + view.document.fire( eventInfo, domEventData ); - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - '* c {id:002}' - ] ) ); - } ); + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 't[]t' + ] ) ); - it( 'xxx', () => { - setModelData( model, modelList( [ - '* a[]', - '* b', - ' c' - ] ) ); + expect( changedBlocks ).to.be.empty; - view.document.fire( eventInfo, domEventData ); + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - ' b', - ' c' - ] ) ); - } ); + it( 'no list editing commands should be executed when outside list when next to a list', () => { + setModelData( model, modelList( [ + 't[ex]t', + '* 1' + ] ) ); - it( 'xxxx', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b', - ' c' - ] ) ); + view.document.fire( eventInfo, domEventData ); - view.document.fire( eventInfo, domEventData ); + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 't[]t', + '* 1' + ] ) ); - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - ' b', - ' c' - ] ) ); - } ); + expect( changedBlocks ).to.be.empty; - it( 'xxxxx', () => { - setModelData( model, modelList( [ - '* a', - ' b[]', - '* c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]', - ' c', - ' d' - ] ) ); - } ); + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + } ); - it( 'xxxxxx', () => { - setModelData( model, modelList( [ - '* a', - ' b[]', - ' * c', - '* b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]', - ' c', - '* b', - ' c' - ] ) ); - } ); + describe( 'only start in a list', () => { + it( 'no list editing commands should be executed when doing delete', () => { + setModelData( model, modelList( [ + '* te[xt', + 'aa]' + ] ) ); - it( 'xxxxxxx', () => { - setModelData( model, modelList( [ - '* a', - ' b[]', - ' * c', - '* b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]', - ' c', - '* b', - ' c' - ] ) ); - } ); + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]' + ] ) ); - it( 'xxxxxxxx', () => { - setModelData( model, modelList( [ - '* []', - ' b', - ' * c', - ' * b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' * b', - ' c' - ] ) ); + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when doing delete (multi-block list)', () => { + setModelData( model, modelList( [ + '* te[xt1', + ' text2', + ' * text3', + 'text4]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'should delete everything till end of selection and merge remaining text', () => { + setModelData( model, modelList( [ + '* text1', + ' tex[t2', + ' * text3', + 'tex]t4' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text1', + ' tex[]t4' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + } ); + + describe( 'only end in a list', () => { + it( 'should delete everything till end of selection', () => { + setModelData( model, modelList( [ + '[', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt {id:001}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should delete everything till the end of selection and adjust remaining block to item list', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should delete everything till the end of selection and adjust remaining item list indentation', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c {id:002}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should delete selection and adjust remaining item list indentation (multi-block)', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' * c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c {id:002}', + ' d' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + // TODO: skipped because below TODO + it.skip( 'should remove selection and adjust remaining list', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' * c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c', + ' d' // TODO: No way currently to adjust this block id <- + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should remove selection and adjust remaining list (multi-block)', () => { + setModelData( model, modelList( [ + 'a[', + '* b', + ' * c', + ' d]d', + ' * e', + ' f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]d', + '* e {id:004}', + ' f' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + } ); + + describe( 'spanning multiple lists', () => { + it( 'should merge lists into one with one list item', () => { + setModelData( model, modelList( [ + '* a[a', + 'b', + '* c]c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]c' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge lists into one with two blocks', () => { + setModelData( model, modelList( [ + '* a', + ' b[b', + 'c', + '* d]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]d' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with two list items', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d]', + '* e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]', + '* e {id:003}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with two list items (multiple blocks)', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d]', + ' e', + '* f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]', + ' e', + '* f {id:004}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with two list items and adjust indentation', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]e', + ' * f {id:004}', + ' g' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with deeper indendation', () => { + setModelData( model, modelList( [ + '* a', + ' * b[', + 'c', + '* d', + ' * e', + ' * f]f', + ' * g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]f', + ' * g {id:006}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with deeper indentation (multiple blocks)', () => { + setModelData( model, modelList( [ + '* a', + ' * b[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]e', + ' * f {id:005}', + ' g' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one and keep items after selection', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d', + ' * e]e', + '* f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]e', + '* f {id:004}', + ' g' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge lists of different types to a single list and keep item lists types', () => { + setModelData( model, modelList( [ + '* a', + '* b[b', + 'c', + '# d]d', + '# d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* b[]d', + '# d {id:004}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge lists of mixed types to a single list and keep item lists types', () => { + setModelData( model, modelList( [ + '* a', + '# b[b', + 'c', + '# d]d', + ' * f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '# b[]d', + ' * f {id:004}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + } ); + } ); + } ); + } ); + + describe( 'forward delete', () => { + beforeEach( () => { + domEventData = new DomEventData( view, { + preventDefault: sinon.spy() + }, { + direction: 'forward', + unit: 'codePoint', + sequence: 1 + } ); + } ); + + describe( 'single block list item', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it.skip( 'should remove list when in empty only element of a list', () => { + setModelData( model, modelList( [ + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + } ); + + it( 'should remove next empty list item', () => { + setModelData( model, modelList( [ + '* b[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b[]' + ] ) ); + + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove next empty list item when current is empty', () => { + setModelData( model, modelList( [ + '* []', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove current list item if empty and replace with indented', () => { + setModelData( model, modelList( [ + '* []', + ' * a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + sinon.assert.calledOnce( mergeForwardCommandExecuteSpy ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}' + ] ) ); + + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove next empty indented item list', () => { + setModelData( model, modelList( [ + '* []', + ' * ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should replace current empty list item with next list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove next empty list item when current is also empty', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'next list item is not empty', () => { + it( 'should merge text from next list item with current list item text', () => { + setModelData( model, modelList( [ + '* a[]', + '* b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should delete next empty item list', () => { + setModelData( model, modelList( [ + '* a[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge text of indented list item with current list item', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove indented empty list item', () => { + setModelData( model, modelList( [ + '* a[]', + ' * ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge text of lower indent list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b[]', + '* c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]c' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should delete next empty list item with lower ident', () => { + setModelData( model, modelList( [ + '* a', + ' * b[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge following item list of first block and adjust it\'s children', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + ' * c {id:002}', + ' * d {id:003}', + ' e', + ' * f {id:005}', + ' * g {id:006}', + ' h' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge following first block of an item list and make second block a first one', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b', + ' b2', + ' * c', + ' * d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + ' b2', + ' * c {id:003}', + ' * d {id:004}', + ' e' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + 'a', + '* [', + '* ]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a', + '* []' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther{id:001}' + ] ) ); + } ); + + it( 'should merge two list items if selection starts in the middle of text', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* text[', + '* ]another' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]another' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* text[', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]ther' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]', + '* b {id:002}', + ' * c {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]c', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[] {id:000}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]e' + ] ) ); + } ); + } ); + } ); + } ); + + describe( 'multi-block list item', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it( 'should remove empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' b[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it.skip( 'should merge following complex list item with current one', () => { + setModelData( model, modelList( [ + '* ', + ' []', + '* b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' []b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge and remove block of same list item', () => { + setModelData( model, modelList( [ + '* []', + ' a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list item with with currently selected list item', () => { + setModelData( model, modelList( [ + '* []', + ' * a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a{id:001}', + ' b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* []', + ' * a', + ' b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list item with first block empty', () => { + setModelData( model, modelList( [ + '* []', + ' * ', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' text' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge next outdented list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a {id:002}', + ' b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge next outdented list item with first block empty', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* ', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'list item after is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* a[]', + '* b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + ' c' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge all following outdented blocks', () => { + setModelData( model, modelList( [ + '* b', + ' * c', + ' c2[]', + ' d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' c2[]d', + ' e' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge complex list item', () => { + setModelData( model, modelList( [ + '* a', + ' a2[]', + '* b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' a2[]b', + ' c', + ' * d {id:004}', + ' e', + ' * f {id:006}', + ' * g {id:007}', + ' h', + ' * i {id:009}', + ' * j {id:010}', + ' k', + ' l' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with next multi-block list item', () => { + setModelData( model, modelList( [ + '* a', + ' a2[]', + '* b', + ' b2' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' a2[]b', + ' b2' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge outdented multi-block list item', () => { + setModelData( model, modelList( [ + '* a', + ' a2[]', + ' * b', + ' b2' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' a2[]b', + ' b2' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge an outdented list item in an outdented list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + ' c[]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' c[]d' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + ' c[]', + ' * ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' c[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with with next outdented list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b[]', + '* c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]c', + ' d' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'collapsed selection in the middle of the list item', () => { + it( 'should merge next indented list item', () => { + setModelData( model, modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]', + ' # Z', + ' V', + '* E', + '* F' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]Z', + ' V', + '* E {id:007}', + '* F {id:008}' + ] ) ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + '* [', + '* ]', + ' ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' ' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text {id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt {id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c {id:002}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* [] {id:000}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e {id:004}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list itemxx', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' ]c', + ' * d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* c', + ' * d {id:003}', + ' e' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge middle block with following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d {id:001}', + ' * e {id:003}', + ' f' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' cd]', + ' * e', + ' f', + ' s' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' * e {id:003}', + ' f', + '* s {id:001}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther {id:001}', + ' text' + ] ) ); + } ); + + // Not related to merge command + it( 'should merge two list items with selection in the middle', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text {id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}', + ' * c {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* [] {id:000}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' c', + ' * d {id:004}', + ' e', + '* f {id:001}', + ' g' + ] ) ); + } ); + } ); + } ); } ); } ); } ); diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js index 3f6bb987b9d..18b6bb0eb0c 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js @@ -28,7 +28,7 @@ describe( 'DocumentListMergeCommand', () => { model.schema.register( 'paragraph', { inheritAllFrom: '$block' } ); model.schema.register( 'blockQuote', { inheritAllFrom: '$container' } ); model.schema.extend( '$container', { allowAttributes: [ 'listType', 'listIndent', 'listItemId' ] } ); - command = new DocumentListMergeCommand( editor ); + command = new DocumentListMergeCommand( editor, 'backward' ); } ); afterEach( () => { @@ -1340,15 +1340,15 @@ describe( 'DocumentListMergeCommand', () => { it( 'should merge with previous list item and keep complex blocks intact', () => { setData( model, modelList( [ '* ', - '* []b{id:b}', + '* []b', ' c', - ' * d{id:d}', + ' * d', ' e', - ' * f{id:f}', - ' * g{id:g}', + ' * f', + ' * g', ' h', - ' * i{id:i}', - ' * j{id:j}', + ' * i', + ' * j', ' k', ' l' ] ) ); @@ -1356,15 +1356,15 @@ describe( 'DocumentListMergeCommand', () => { command.execute(); expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:b}', + '* []b', ' c', - ' * d{id:d}', + ' * d', ' e', - ' * f{id:f}', - ' * g{id:g}', + ' * f', + ' * g{', ' h', - ' * i{id:i}', - ' * j{id:j}', + ' * i', + ' * j', ' k', ' l' ] ) ); From 03b1406c2bd578752f0a448d12b2b3b75308621d Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 25 Jan 2022 11:03:37 +0100 Subject: [PATCH 18/44] Code refactoring: split DocumentListEditing integration tests into separate files for better readability. --- .../documentlistediting-integrations.js | 5294 ----------------- .../documentlist/integrations/clipboard.js | 509 ++ .../tests/documentlist/integrations/delete.js | 3567 +++++++++++ .../tests/documentlist/integrations/enter.js | 1340 +++++ 4 files changed, 5416 insertions(+), 5294 deletions(-) delete mode 100644 packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js create mode 100644 packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js create mode 100644 packages/ckeditor5-list/tests/documentlist/integrations/delete.js create mode 100644 packages/ckeditor5-list/tests/documentlist/integrations/enter.js diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js b/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js deleted file mode 100644 index b540708fbab..00000000000 --- a/packages/ckeditor5-list/tests/documentlist/documentlistediting-integrations.js +++ /dev/null @@ -1,5294 +0,0 @@ -/** - * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. - * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license - */ - -import DocumentListEditing from '../../src/documentlist/documentlistediting'; - -import BoldEditing from '@ckeditor/ckeditor5-basic-styles/src/bold/boldediting'; -import UndoEditing from '@ckeditor/ckeditor5-undo/src/undoediting'; -import ClipboardPipeline from '@ckeditor/ckeditor5-clipboard/src/clipboardpipeline'; -import BlockQuoteEditing from '@ckeditor/ckeditor5-block-quote/src/blockquoteediting'; -import HeadingEditing from '@ckeditor/ckeditor5-heading/src/headingediting'; -import TableEditing from '@ckeditor/ckeditor5-table/src/tableediting'; -import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph'; -import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; -import EventInfo from '@ckeditor/ckeditor5-utils/src/eventinfo'; - -import VirtualTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/virtualtesteditor'; -import { - getData as getModelData, - parse as parseModel, - setData as setModelData -} from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; -import { parse as parseView } from '@ckeditor/ckeditor5-engine/src/dev-utils/view'; -import { DomEventData } from '@ckeditor/ckeditor5-engine'; - -import stubUid from './_utils/uid'; -import { modelList } from './_utils/utils'; -import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubblingeventinfo'; - -describe( 'DocumentListEditing integrations', () => { - let editor, model, modelDoc, modelRoot, view; - - testUtils.createSinonSandbox(); - - beforeEach( async () => { - editor = await VirtualTestEditor.create( { - plugins: [ Paragraph, ClipboardPipeline, BoldEditing, DocumentListEditing, UndoEditing, - BlockQuoteEditing, TableEditing, HeadingEditing ] - } ); - - model = editor.model; - modelDoc = model.document; - modelRoot = modelDoc.getRoot(); - - view = editor.editing.view; - - model.schema.extend( 'paragraph', { - allowAttributes: 'foo' - } ); - - model.schema.register( 'nonListable', { - allowWhere: '$block', - allowContentOf: '$block', - inheritTypesFrom: '$block', - allowAttributes: 'foo' - } ); - - editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); - - // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. - sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); - stubUid(); - } ); - - afterEach( async () => { - await editor.destroy(); - } ); - - describe( 'clipboard integration', () => { - describe( 'copy and getSelectedContent', () => { - it( 'should be able to downcast part of a nested list', () => { - setModelData( model, - 'A' + - '[B1' + - 'B2' + - 'C1]' + - 'C2' - ); - - const modelFragment = model.getSelectedContent( model.document.selection ); - const viewFragment = editor.data.toView( modelFragment ); - const data = editor.data.htmlProcessor.toData( viewFragment ); - - expect( data ).to.equal( - '
    ' + - '
  • ' + - '

    B1

    ' + - '

    B2

    ' + - '
      ' + - '
    • C1
      • ' + - '
    ' + - '
    • ' + - '
' - ); - } ); - - it( 'should be able to downcast part of a deep nested list', () => { - setModelData( model, - 'A' + - 'B1' + - 'B2' + - '[C1' + - 'C2]' - ); - - const modelFragment = model.getSelectedContent( model.document.selection ); - const viewFragment = editor.data.toView( modelFragment ); - const data = editor.data.htmlProcessor.toData( viewFragment ); - - expect( data ).to.equal( - '
    ' + - '
  • ' + - '

    C1

    ' + - '

    C2

    ' + - '
    • ' + - '
' - ); - } ); - } ); - - describe( 'paste and insertContent integration', () => { - it( 'should be triggered on DataController#insertContent()', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - editor.model.insertContent( - parseModel( - 'X' + - 'Y', - model.schema - ) - ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BX' + - 'Y[]' + - 'C' - ); - } ); - - it( 'should be triggered when selectable is passed', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - model.insertContent( - parseModel( - 'X' + - 'Y', - model.schema - ), - model.createRange( - model.createPositionFromPath( modelRoot, [ 1, 1 ] ), - model.createPositionFromPath( modelRoot, [ 1, 1 ] ) - ) - ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'B[]X' + - 'Y' + - 'C' - ); - } ); - - // Just checking that it doesn't crash. #69 - it( 'should work if an element is passed to DataController#insertContent()', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - model.change( writer => { - const paragraph = writer.createElement( 'paragraph', { listType: 'bulleted', listItemId: 'x', listIndent: '0' } ); - writer.insertText( 'X', paragraph ); - - model.insertContent( paragraph ); - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BX[]' + - 'C' - ); - } ); - - // Just checking that it doesn't crash. #69 - it( 'should work if an element is passed to DataController#insertContent() - case #69', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - model.change( writer => { - model.insertContent( writer.createText( 'X' ) ); - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BX[]' + - 'C' - ); - } ); - - it( 'should fix indents of pasted list items', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • X
    • Y
' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BX' + - 'Y[]' + - 'C' - ); - } ); - - it( 'should not fix indents of list items that are separated by non-list element', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • W
    • X

Y

  • Z
' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BW' + - 'X' + - 'Y' + - 'Z[]' + - 'C' - ); - } ); - - it( 'should co-work correctly with post fixer', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '

X

  • Y
' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BX' + - 'Y[]' + - 'C' - ); - } ); - - it( 'should work if items are pasted between paragraph elements', () => { - // Wrap all changes in one block to avoid post-fixing the selection - // (which may be incorret) in the meantime. - model.change( () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • X
    • Y
' ) - } ); - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'B' + - 'X' + - 'Y[]' + - 'C' - ); - } ); - - it( 'should create correct model when list items are pasted in top-level list', () => { - setModelData( model, - 'A[]' + - 'B' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • X
    • Y
' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'AX' + - 'Y[]' + - 'B' - ); - } ); - - it( 'should create correct model when list items are pasted in non-list context', () => { - setModelData( model, - 'A[]' + - 'B' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • X
    • Y
' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'AX' + - 'Y[]' + - 'B' - ); - } ); - - it( 'should not crash when "empty content" is inserted', () => { - setModelData( model, '[]' ); - - expect( () => { - model.change( writer => { - editor.model.insertContent( writer.createDocumentFragment() ); - } ); - } ).not.to.throw(); - } ); - - it( 'should correctly handle item that is pasted without its parent', () => { - // Wrap all changes in one block to avoid post-fixing the selection - // (which may be incorret) in the meantime. - model.change( () => { - setModelData( model, - 'Foo' + - 'A' + - 'B' + - '[]' + - 'Bar' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • X
    • ' ) - } ); - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'Foo' + - 'A' + - 'B' + - 'X[]' + - 'Bar' - ); - } ); - - it( 'should correctly handle item that is pasted without its parent #2', () => { - // Wrap all changes in one block to avoid post-fixing the selection - // (which may be incorret) in the meantime. - model.change( () => { - setModelData( model, - 'Foo' + - 'A' + - 'B' + - '[]' + - 'Bar' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
  • X
    • Y
    • ' ) - } ); - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'Foo' + - 'A' + - 'B' + - 'X' + - 'Y[]' + - 'Bar' - ); - } ); - - it( 'should handle block elements inside pasted list #1', () => { - setModelData( model, - 'A' + - 'B[]' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
    • W
      • X

        Y

        Z
    ' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'A' + - 'BW' + - 'X' + - 'Y' + - 'Z[]' + - 'C' - ); - } ); - - it( 'should handle block elements inside pasted list #2', () => { - setModelData( model, - 'A[]' + - 'B' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
    • W
      • X

        Y

        Z
    ' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'AW' + - 'X' + - 'Y' + - 'Z[]' + - 'B' + - 'C' - ); - } ); - - it( 'should handle block elements inside pasted list #3', () => { - setModelData( model, - 'A[]' + - 'B' + - 'C' - ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '

    • W

      X

      Y

    • Z
    ' ) - } ); - - expect( getModelData( model ) ).to.equalMarkup( - 'AW' + - 'X' + - 'Y' + - 'Z[]' + - 'B' + - 'C' - ); - } ); - - it( 'should properly handle split of list items with non-standard converters', () => { - setModelData( model, - 'A[]' + - 'B' + - 'C' - ); - - editor.model.schema.register( 'splitBlock', { allowWhere: '$block' } ); - - editor.conversion.for( 'downcast' ).elementToElement( { model: 'splitBlock', view: 'splitBlock' } ); - editor.conversion.for( 'upcast' ).add( dispatcher => dispatcher.on( 'element:splitBlock', ( evt, data, conversionApi ) => { - const splitBlock = conversionApi.writer.createElement( 'splitBlock' ); - - conversionApi.consumable.consume( data.viewItem, { name: true } ); - conversionApi.safeInsert( splitBlock, data.modelCursor ); - conversionApi.updateConversionResult( splitBlock, data ); - } ) ); - - const clipboard = editor.plugins.get( 'ClipboardPipeline' ); - - clipboard.fire( 'inputTransformation', { - content: parseView( '
    • ab
    ' ) - } ); - - expect( getModelData( model, { withoutSelection: true } ) ).to.equalMarkup( - 'Aa' + - '' + - 'b' + - 'B' + - 'C' - ); - } ); - } ); - } ); - - describe( 'enter key handling', () => { - const changedBlocks = []; - let domEventData, splitBeforeCommand, splitAfterCommand, indentCommand, - eventInfo, splitBeforeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; - - beforeEach( () => { - eventInfo = new EventInfo( view.document, 'enter' ); - domEventData = new DomEventData( view.document, { - preventDefault: sinon.spy() - } ); - - splitBeforeCommand = editor.commands.get( 'splitListItemBefore' ); - splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); - indentCommand = editor.commands.get( 'outdentList' ); - - splitBeforeCommandExecuteSpy = sinon.spy( splitBeforeCommand, 'execute' ); - splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); - outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); - - changedBlocks.length = 0; - - splitBeforeCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - - splitAfterCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - - indentCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - } ); - - describe( 'collapsed selection', () => { - describe( 'with just one block per list item', () => { - it( 'should outdent if the slection in the only empty list item (convert into paragraph and turn off the list)', () => { - setModelData( model, modelList( [ - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 0 ) - ] ); - - sinon.assert.calledOnce( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should outdent if the slection in the last empty list item (convert the item into paragraph)', () => { - setModelData( model, modelList( [ - '* a', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '[]' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.calledOnce( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another list item when the selection in a non-empty only list item', () => { - setModelData( model, modelList( [ - '* a[]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* [] {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should outdent if the selection in an empty, last sub-list item', () => { - setModelData( model, modelList( [ - '* a', - ' # b', - ' * c', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' # b', - ' * c', - ' # []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 3 ) - ] ); - - sinon.assert.calledOnce( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - - describe( 'with multiple blocks in a list item', () => { - it( 'should outdent if the selection is anchored in an empty, last item block', () => { - setModelData( model, modelList( [ - '* a', - ' # b', - ' # []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' # b', - '* []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 2 ) - ] ); - - sinon.assert.calledOnce( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should outdent if the selection is anchored in an empty, only sub-item block', () => { - setModelData( model, modelList( [ - '* a', - ' # b', - ' * []', - ' #' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' # b', - ' # []', - ' #' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 2 ) - ] ); - - sinon.assert.calledOnce( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another block when the selection at the start of a non-empty first block', () => { - setModelData( model, modelList( [ - '* a[]', - ' b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' b', - ' c' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should create another block when the selection at the end of a non-empty first block', () => { - setModelData( model, modelList( [ - '* []a', - ' b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' []a', - ' b', - ' c' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should create another block when the selection at the start of a non-empty last block', () => { - setModelData( model, modelList( [ - '* a', - ' b', - ' []c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b', - ' ', - ' []c' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should create another block when the selection at the end of a non-empty last block', () => { - setModelData( model, modelList( [ - '* a', - ' b', - ' c[]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b', - ' c', - ' []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should create another block when the selection in an empty middle block', () => { - setModelData( model, modelList( [ - '* a', - ' []', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' ', - ' []', - ' c' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should create another list item when the selection in an empty last block (two blocks in total)', () => { - setModelData( model, modelList( [ - '* a', - ' []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* [] {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another list item when the selection in an empty last block (three blocks in total)', () => { - setModelData( model, modelList( [ - '* a', - ' b', - ' []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b', - '* [] {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 2 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another list item when the selection in an empty last block (followed by a list item)', () => { - setModelData( model, modelList( [ - '* a', - ' b', - ' []', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b', - '* [] {id:a00}', - '* ' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 2 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another list item when the selection in an empty first block (followed by another block)', () => { - setModelData( model, modelList( [ - '* []', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.calledOnce( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another list item when the selection in an empty first block (followed by multiple blocks)', () => { - setModelData( model, modelList( [ - '* []', - ' a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* a {id:a00}', - ' b' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ), - modelRoot.getChild( 2 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.calledOnce( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should create another list item when the selection in an empty first block (followed by multiple blocks and an item)', - () => { - setModelData( model, modelList( [ - '* []', - ' a', - ' b', - '* c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* a {id:a00}', - ' b', - '* c' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ), - modelRoot.getChild( 2 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.calledOnce( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - } ); - - describe( 'non-collapsed selection', () => { - describe( 'with just one block per list item', () => { - it( 'should create another list item if the selection contains some content at the end of the list item', () => { - setModelData( model, modelList( [ - '* a[b]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* [] {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should create another list item if the selection contains some content at the start of the list item', () => { - setModelData( model, modelList( [ - '* [a]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - '* []b {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content and turn off the list if slection contains all content at the zero indent level', () => { - setModelData( model, modelList( [ - '* [a', - '* b]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content and move the selection when it contains some content at the zero indent level', () => { - setModelData( model, modelList( [ - '* a[b', - '* b]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content when the selection contains all content at a deeper indent level', () => { - setModelData( model, modelList( [ - '* a', - ' # b', - ' * [c', - ' * d]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' # b', - ' * []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - describe( 'cross-indent level selection', () => { - it( 'should clean the content and remove list across different indentation levels (list the only content)', () => { - setModelData( model, modelList( [ - '* [ab', - ' # cd]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (one level, entire blocks)', () => { - setModelData( model, modelList( [ - 'foo', - '* [ab', - ' # cd]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'foo', - '* []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (one level, subset of blocks)', () => { - setModelData( model, modelList( [ - 'foo', - '* a[b', - ' # c]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'foo', - '* a', - ' # []d' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (two levels, entire blocks)', () => { - setModelData( model, modelList( [ - '* [ab', - ' # cd', - ' * ef]', - ' * gh' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' * gh {id:003}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (two levels, subset of blocks)', () => { - setModelData( model, modelList( [ - '* a[b', - ' # cd', - ' * e]f', - ' * gh' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * []f {id:002}', - ' * gh {id:003}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (three levels, entire blocks)', () => { - setModelData( model, modelList( [ - 'foo', - '* [ab', - ' # cd', - ' * ef', - ' * gh]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'foo', - '* []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content and remove list across different indentation levels ' + - '(three levels, list the only content)', () => { - setModelData( model, modelList( [ - '* [ab', - ' # cd', - ' * ef', - ' * gh]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (three levels, subset of blocks)', () => { - setModelData( model, modelList( [ - '* a[b', - ' # cd', - ' * ef', - ' # g]h', - ' * ij' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' # []h {id:003}', - '* ij {id:004}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (one level, start at first, entire blocks)', () => { - setModelData( model, modelList( [ - '* ab', - ' # [cd', - ' * ef', - ' * gh]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' # []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (one level, start at first, part of blocks)', () => { - setModelData( model, modelList( [ - '* ab', - ' # c[d', - ' * ef', - ' * g]h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' # c', - ' * []h {id:003}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (level up then down, subset of blocks)', () => { - setModelData( model, modelList( [ - '* ab', - ' # c[d', - ' * ef', - ' # g]h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' # c', - ' # []h {id:003}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (level up then down, entire of blocks)', () => { - setModelData( model, modelList( [ - '* ab', - ' # [cd', - ' * ef', - ' # gh]', - '* ij' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' # []', - '* ij {id:004}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the content across different indentation levels (level up then down, preceded by an item)', () => { - setModelData( model, modelList( [ - '* ab', - ' # cd', - ' # [ef', - ' * gh', - ' # ij]', - '* kl' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' # cd', - ' # []', - '* kl {id:005}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - } ); - } ); - - describe( 'with multiple blocks in a list item', () => { - it( 'should clean the selected content (partial blocks)', () => { - setModelData( model, modelList( [ - '* a[b', - ' c]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* []d {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (entire blocks)', () => { - setModelData( model, modelList( [ - 'foo', - '* [ab', - ' cd]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'foo', - '* []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (entire block, middle one)', () => { - setModelData( model, modelList( [ - '* ab', - ' [cd]', - ' ef' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' []', - ' ef' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (entire blocks, starting from the second)', () => { - setModelData( model, modelList( [ - '* ab', - ' [cd', - ' ef]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - // Generally speaking, we'd rather expect something like this: - // * ab - // [] - // But there is no easy way to tell what the original selection looked like when it came to EnterCommand#afterExecute. - // Enter deletes all the content first [cd, ef] and in #afterExecute it looks like the original selection was: - // * ab - // [] - // and the algorithm falls back to splitting in this case. There's even a test for this kind of selection. - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - '* [] {id:a00}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [ - modelRoot.getChild( 1 ) - ] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (partial blocks, starting from the second)', () => { - setModelData( model, modelList( [ - '* ab', - ' c[d', - ' e]f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' c', - ' []f' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (entire blocks, three blocks in total)', () => { - setModelData( model, modelList( [ - '* [ab', - ' cd', - ' ef]', - '* gh' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* gh {id:003}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (entire blocks, across list items)', () => { - setModelData( model, modelList( [ - 'foo', - '* [ab', - ' cd', - ' ef', - '* gh]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'foo', - '* []' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (entire blocks + a partial block, across list items)', () => { - setModelData( model, modelList( [ - '* [ab', - ' cd', - ' ef', - '* g]h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - '* []h {id:003}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (partial blocks, across list items)', () => { - setModelData( model, modelList( [ - '* ab', - ' cd', - ' e[f', - '* g]h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' cd', - ' e', - '* []h' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - describe( 'cross-indent level selection', () => { - it( 'should clean the selected content (partial blocks)', () => { - setModelData( model, modelList( [ - '* ab', - ' * cd', - ' e[f', - ' gh', - ' * i]j' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' * cd', - ' e', - ' * []j {id:004}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (partial blocks + entire block)', () => { - setModelData( model, modelList( [ - '* ab', - ' * cd', - ' e[f', - ' gh', - ' * ij]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' * cd', - ' e', - ' * [] {id:004}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - - it( 'should clean the selected content (across two middle levels)', () => { - setModelData( model, modelList( [ - '* ab', - ' c[d', - ' * ef', - ' g]h', - ' * ij' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ab', - ' c', - ' * []h', - ' * ij {id:004}' - ] ) ); - - expect( changedBlocks ).to.deep.equal( [] ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.undefined; - } ); - } ); - } ); - } ); - } ); - - describe( 'delete keys handling', () => { - const changedBlocks = []; - let domEventData, mergeBackwardCommand, mergeForwardCommand, splitAfterCommand, indentCommand, - eventInfo, - mergeBackwardCommandExecuteSpy, mergeForwardCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; - - beforeEach( () => { - eventInfo = new BubblingEventInfo( view.document, 'delete' ); - - splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); - indentCommand = editor.commands.get( 'outdentList' ); - mergeBackwardCommand = editor.commands.get( 'mergeListItemBackward' ); - mergeForwardCommand = editor.commands.get( 'mergeListItemForward' ); - - splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); - outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); - mergeBackwardCommandExecuteSpy = sinon.spy( mergeBackwardCommand, 'execute' ); - mergeForwardCommandExecuteSpy = sinon.spy( mergeForwardCommand, 'execute' ); - - changedBlocks.length = 0; - - splitAfterCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - - indentCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - - mergeBackwardCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - - mergeForwardCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); - } ); - } ); - - describe( 'backward delete', () => { - beforeEach( () => { - domEventData = new DomEventData( view, { - preventDefault: sinon.spy() - }, { - direction: 'backward', - unit: 'codePoint', - sequence: 1 - } ); - } ); - - describe( 'single block list item', () => { - describe( 'collapsed selection at the beginning of a list item', () => { - describe( 'item before is empty', () => { - it( 'should remove list when in empty only element of a list', () => { - setModelData( model, modelList( [ - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); - } ); - - it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b {id:001}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - - describe( 'item before is not empty', () => { - it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented empty list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should keep merged list item\'s children', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - } ); - - describe( 'collapsed selection at the end of a list item', () => { - describe( 'item after is empty', () => { - it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}' - ] ) ); - } ); - - // Default behaviour of backspace? - it( 'should merge empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - } ); - - it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}' - ] ) ); - } ); - - it( 'should merge indented empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); - } ); - - it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); - } ); - } ); - - describe( 'item before is not empty', () => { - it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - } ); - - it( 'should merge empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - } ); - - it( 'should merge indented list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - } ); - - it( 'should merge indented empty list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - } ); - - it( 'should merge list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); - } ); - - it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); - } ); - - it( 'should keep merged list item\'s children', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - } ); - } ); - } ); - - describe( 'non-collapsed selection starting in first block of a list item', () => { - describe( 'first position in empty block', () => { - it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - 'a', - '* [', - '* ]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a', - '* []' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); - } ); - } ); - - describe( 'first position in non-empty block', () => { - it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}' - ] ) ); - } ); - - it( 'should merge two list items if selection is in the middle', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* text[', - '* ]another' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]another' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* text[', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]ther' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* b {id:002}', - ' * c{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]c', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]{id:000}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]e' - ] ) ); - } ); - } ); - } ); - } ); - - describe( 'multi-block list item', () => { - describe( 'collapsed selection at the beginning of a list item', () => { - describe( 'item before is empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* ', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it.skip( 'should merge with previous list item and keep complex blocks intact ', () => { - setModelData( model, modelList( [ - '* ', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with first block empty with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []', - ' a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' a' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b', - ' * c {id:003}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented empty list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - - describe( 'item before is not empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* a', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge block to a previous list item', () => { - setModelData( model, modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge with previous list item and keep complex blocks intact', () => { - setModelData( model, modelList( [ - '* a', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge list item with first block empty with previous list item', () => { - setModelData( model, modelList( [ - '* a', - '* []', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list item with with previous list item as blocks', () => { - setModelData( model, modelList( [ - '* a', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []a', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); - } ); - - it( 'should merge indented list having block and indented list item with previous list item', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented empty list item with previous list item', () => { - setModelData( model, modelList( [ - '* a', - ' * []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c', - ' d' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - } ); - - describe( 'collapsed selection in the middle of the list item', () => { - it( 'should merge block to a previous list item', () => { - setModelData( model, modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' []X', - ' # Z', - ' V', - '* E', - '* F' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' []X', - ' # Z', - ' V', - '* E', - '* F' - ] ) ); - } ); - } ); - - describe( 'non-collapsed selection starting in first block of a list item', () => { - describe( 'first position in empty block', () => { - it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - '* [', - '* ]', - ' ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' ' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); - } ); - - it( 'should delete all following items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - ' text', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:004}' - ] ) ); - } ); - - it( 'should delete all following items till the end of selection and merge last list itemxx', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' ]c', - ' * d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* c', - ' * d {id:003}', - ' e' - ] ) ); - } ); - - it( 'should delete items till the end of selection and merge middle block with following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' c]d', - ' * e', - ' f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d{id:001}', - ' * e{id:003}', - ' f' - ] ) ); - } ); - - it( 'should delete items till the end of selection and merge following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' cd]', - ' * e', - ' f', - ' s' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' * e {id:003}', - ' f', - '* s {id:001}' - ] ) ); - } ); - } ); - - describe( 'first position in non-empty block', () => { - it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}', - ' text' - ] ) ); - } ); - - // Not related to merge command - it( 'should merge two list items with selection in the middle', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}', - ' * c {id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]', - ' c', - ' * d', - ' e', - ' f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' c', - ' * d {id:004}', - ' e', - '* f {id:001}', - ' g' - ] ) ); - } ); - } ); - } ); - } ); - - describe( 'selection outside list', () => { - describe( 'collapsed selection', () => { - it( 'no list editing commands should be executed outside list (empty paragraph)', () => { - setModelData( model, - '[]' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - '[]' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed outside list (selection at the beginning of text)', () => { - setModelData( model, - '[]text' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - '[]text' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed outside list (selection at the end of text)', () => { - setModelData( model, - 'text[]' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - 'tex[]' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed outside list (selection in the middle of text)', () => { - setModelData( model, - 'te[]xt' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - 't[]xt' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed next to a list', () => { - setModelData( model, modelList( [ - '1[]', - '* 2' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]', - '* 2' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed when merging two lists', () => { - setModelData( model, modelList( [ - '* 1', - '[]2', - '* 3' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* 1[]2', - '* 3 {id:002}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed when merging two lists - one nested', () => { - setModelData( model, modelList( [ - '* 1', - '[]2', - '* 3', - ' * 4' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* 1[]2', - '* 3 {id:002}', - ' * 4 {id:003}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'empty list should be deleted', () => { - setModelData( model, modelList( [ - '* ', - '[]2', - '* 3' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]2', - '* 3 {id:002}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - } ); - - describe( 'non-collapsed selection', () => { - describe( 'outside list', () => { - it( 'no list editing commands should be executed', () => { - setModelData( model, modelList( [ - 't[ex]t' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 't[]t' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed when outside list when next to a list', () => { - setModelData( model, modelList( [ - 't[ex]t', - '* 1' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 't[]t', - '* 1' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - } ); - - describe( 'only start in a list', () => { - it( 'no list editing commands should be executed when doing delete', () => { - setModelData( model, modelList( [ - '* te[xt', - 'aa]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'no list editing commands should be executed when doing delete (multi-block list)', () => { - setModelData( model, modelList( [ - '* te[xt1', - ' text2', - ' * text3', - 'text4]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - } ); - - it( 'should delete everything till end of selection and merge remaining text', () => { - setModelData( model, modelList( [ - '* text1', - ' tex[t2', - ' * text3', - 'tex]t4' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text1', - ' tex[]t4' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - } ); - - describe( 'only end in a list', () => { - it( 'should delete everything till end of selection', () => { - setModelData( model, modelList( [ - '[', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt {id:001}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should delete everything till the end of selection and adjust remaining block to item list', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should delete everything till the end of selection and adjust remaining item list indentation', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c {id:002}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should delete selection and adjust remaining item list indentation (multi-block)', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' * c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c {id:002}', - ' d' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - // TODO: skipped because below TODO - it.skip( 'should remove selection and adjust remaining list', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' * c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c', - ' d' // TODO: No way currently to adjust this block id <- - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should remove selection and adjust remaining list (multi-block)', () => { - setModelData( model, modelList( [ - 'a[', - '* b', - ' * c', - ' d]d', - ' * e', - ' f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]d', - '* e {id:004}', - ' f' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - } ); - - describe( 'spanning multiple lists', () => { - it( 'should merge lists into one with one list item', () => { - setModelData( model, modelList( [ - '* a[a', - 'b', - '* c]c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]c' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge lists into one with two blocks', () => { - setModelData( model, modelList( [ - '* a', - ' b[b', - 'c', - '* d]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]d' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge two lists into one with two list items', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d]', - '* e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - '* e {id:003}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge two lists into one with two list items (multiple blocks)', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d]', - ' e', - '* f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - ' e', - '* f {id:004}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge two lists into one with two list items and adjust indentation', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d', - ' * e]e', - ' * f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]e', - ' * f {id:004}', - ' g' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge two lists into one with deeper indendation', () => { - setModelData( model, modelList( [ - '* a', - ' * b[', - 'c', - '* d', - ' * e', - ' * f]f', - ' * g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]f', - ' * g {id:006}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge two lists into one with deeper indentation (multiple blocks)', () => { - setModelData( model, modelList( [ - '* a', - ' * b[', - 'c', - '* d', - ' * e]e', - ' * f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]e', - ' * f {id:005}', - ' g' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge two lists into one and keep items after selection', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d', - ' * e]e', - '* f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]e', - '* f {id:004}', - ' g' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge lists of different types to a single list and keep item lists types', () => { - setModelData( model, modelList( [ - '* a', - '* b[b', - 'c', - '# d]d', - '# d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* b[]d', - '# d {id:004}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - - it( 'should merge lists of mixed types to a single list and keep item lists types', () => { - setModelData( model, modelList( [ - '* a', - '# b[b', - 'c', - '# d]d', - ' * f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '# b[]d', - ' * f {id:004}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - } ); - } ); - } ); - } ); - } ); - - describe( 'forward delete', () => { - beforeEach( () => { - domEventData = new DomEventData( view, { - preventDefault: sinon.spy() - }, { - direction: 'forward', - unit: 'codePoint', - sequence: 1 - } ); - } ); - - describe( 'single block list item', () => { - describe( 'collapsed selection at the end of a list item', () => { - describe( 'item after is empty', () => { - it.skip( 'should remove list when in empty only element of a list', () => { - setModelData( model, modelList( [ - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); - } ); - - it( 'should remove next empty list item', () => { - setModelData( model, modelList( [ - '* b[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b[]' - ] ) ); - - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should remove next empty list item when current is empty', () => { - setModelData( model, modelList( [ - '* []', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should remove current list item if empty and replace with indented', () => { - setModelData( model, modelList( [ - '* []', - ' * a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - sinon.assert.calledOnce( mergeForwardCommandExecuteSpy ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}' - ] ) ); - - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should remove next empty indented item list', () => { - setModelData( model, modelList( [ - '* []', - ' * ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should replace current empty list item with next list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should remove next empty list item when current is also empty', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - - describe( 'next list item is not empty', () => { - it( 'should merge text from next list item with current list item text', () => { - setModelData( model, modelList( [ - '* a[]', - '* b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should delete next empty item list', () => { - setModelData( model, modelList( [ - '* a[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge text of indented list item with current list item', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should remove indented empty list item', () => { - setModelData( model, modelList( [ - '* a[]', - ' * ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge text of lower indent list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b[]', - '* c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]c' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should delete next empty list item with lower ident', () => { - setModelData( model, modelList( [ - '* a', - ' * b[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge following item list of first block and adjust it\'s children', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - ' * c {id:002}', - ' * d {id:003}', - ' e', - ' * f {id:005}', - ' * g {id:006}', - ' h' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge following first block of an item list and make second block a first one', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b', - ' b2', - ' * c', - ' * d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - ' b2', - ' * c {id:003}', - ' * d {id:004}', - ' e' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - } ); - - describe( 'non-collapsed selection starting in first block of a list item', () => { - describe( 'first position in empty block', () => { - it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - 'a', - '* [', - '* ]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a', - '* []' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); - } ); - } ); - - describe( 'first position in non-empty block', () => { - it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}' - ] ) ); - } ); - - it( 'should merge two list items if selection starts in the middle of text', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* text[', - '* ]another' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]another' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* text[', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]ther' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* b {id:002}', - ' * c {id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]c', - ' * d {id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[] {id:000}', - ' * d {id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]e' - ] ) ); - } ); - } ); - } ); - } ); - - describe( 'multi-block list item', () => { - describe( 'collapsed selection at the end of a list item', () => { - describe( 'item after is empty', () => { - it( 'should remove empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' b[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it.skip( 'should merge following complex list item with current one', () => { - setModelData( model, modelList( [ - '* ', - ' []', - '* b', - ' c', - ' * d {id:d}', - ' e', - ' * f {id:f}', - ' * g {id:g}', - ' h', - ' * i {id:i}', - ' * j {id:j}', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' []b', - ' c', - ' * d {id:d}', - ' e', - ' * f {id:f}', - ' * g {id:g}', - ' h', - ' * i {id:i}', - ' * j {id:j}', - ' k', - ' l' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge and remove block of same list item', () => { - setModelData( model, modelList( [ - '* []', - ' a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented list item with with currently selected list item', () => { - setModelData( model, modelList( [ - '* []', - ' * a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}', - ' b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* []', - ' * a', - ' b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b', - ' * c {id:003}' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented list item with first block empty', () => { - setModelData( model, modelList( [ - '* []', - ' * ', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge next outdented list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a {id:002}', - ' b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge next outdented list item with first block empty', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* ', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - - describe( 'list item after is not empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* a[]', - '* b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - ' c' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge all following outdented blocks', () => { - setModelData( model, modelList( [ - '* b', - ' * c', - ' c2[]', - ' d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' c2[]d', - ' e' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge complex list item', () => { - setModelData( model, modelList( [ - '* a', - ' a2[]', - '* b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' a2[]b', - ' c', - ' * d {id:004}', - ' e', - ' * f {id:006}', - ' * g {id:007}', - ' h', - ' * i {id:009}', - ' * j {id:010}', - ' k', - ' l' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge list item with next multi-block list item', () => { - setModelData( model, modelList( [ - '* a', - ' a2[]', - '* b', - ' b2' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' a2[]b', - ' b2' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge outdented multi-block list item', () => { - setModelData( model, modelList( [ - '* a', - ' a2[]', - ' * b', - ' b2' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' a2[]b', - ' b2' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge an outdented list item in an outdented list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - ' c[]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' c[]d' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge indented empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - ' c[]', - ' * ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' c[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it( 'should merge list item with with next outdented list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b[]', - '* c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]c', - ' d' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - } ); - } ); - - describe( 'collapsed selection in the middle of the list item', () => { - it( 'should merge next indented list item', () => { - setModelData( model, modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' X[]', - ' # Z', - ' V', - '* E', - '* F' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' X[]Z', - ' V', - '* E {id:007}', - '* F {id:008}' - ] ) ); - } ); - } ); - - describe( 'non-collapsed selection starting in first block of a list item', () => { - describe( 'first position in empty block', () => { - it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - '* [', - '* ]', - ' ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' ' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text {id:001}' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt {id:001}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c {id:002}', - ' * d {id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* [] {id:000}', - ' * d {id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); - } ); - - it( 'should delete all following items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - ' text', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e {id:004}' - ] ) ); - } ); - - it( 'should delete all following items till the end of selection and merge last list itemxx', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' ]c', - ' * d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* c', - ' * d {id:003}', - ' e' - ] ) ); - } ); - - it( 'should delete items till the end of selection and merge middle block with following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' c]d', - ' * e', - ' f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d {id:001}', - ' * e {id:003}', - ' f' - ] ) ); - } ); - - it( 'should delete items till the end of selection and merge following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' cd]', - ' * e', - ' f', - ' s' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' * e {id:003}', - ' f', - '* s {id:001}' - ] ) ); - } ); - } ); - - describe( 'first position in non-empty block', () => { - it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther {id:001}', - ' text' - ] ) ); - } ); - - // Not related to merge command - it( 'should merge two list items with selection in the middle', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); - } ); - - it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text {id:001}' - ] ) ); - } ); - - it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}', - ' * c {id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); - } ); - - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* [] {id:000}', - ' * d {id:003}' - ] ) ); - } ); - - it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); - } ); - - it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]', - ' c', - ' * d', - ' e', - ' f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' c', - ' * d {id:004}', - ' e', - '* f {id:001}', - ' g' - ] ) ); - } ); - } ); - } ); - } ); - } ); - } ); -} ); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js b/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js new file mode 100644 index 00000000000..f5c1266297b --- /dev/null +++ b/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js @@ -0,0 +1,509 @@ +/** + * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license + */ + +import DocumentListEditing from '../../../src/documentlist/documentlistediting'; + +import BoldEditing from '@ckeditor/ckeditor5-basic-styles/src/bold/boldediting'; +import UndoEditing from '@ckeditor/ckeditor5-undo/src/undoediting'; +import ClipboardPipeline from '@ckeditor/ckeditor5-clipboard/src/clipboardpipeline'; +import BlockQuoteEditing from '@ckeditor/ckeditor5-block-quote/src/blockquoteediting'; +import HeadingEditing from '@ckeditor/ckeditor5-heading/src/headingediting'; +import TableEditing from '@ckeditor/ckeditor5-table/src/tableediting'; +import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph'; +import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; + +import VirtualTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/virtualtesteditor'; +import { + getData as getModelData, + parse as parseModel, + setData as setModelData +} from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; +import { parse as parseView } from '@ckeditor/ckeditor5-engine/src/dev-utils/view'; + +import stubUid from '../_utils/uid'; + +describe( 'DocumentListEditing integrations: clipboard copy & paste', () => { + let editor, model, modelDoc, modelRoot, view; + + testUtils.createSinonSandbox(); + + beforeEach( async () => { + editor = await VirtualTestEditor.create( { + plugins: [ + Paragraph, ClipboardPipeline, BoldEditing, DocumentListEditing, UndoEditing, + BlockQuoteEditing, TableEditing, HeadingEditing + ] + } ); + + model = editor.model; + modelDoc = model.document; + modelRoot = modelDoc.getRoot(); + + view = editor.editing.view; + + model.schema.extend( 'paragraph', { + allowAttributes: 'foo' + } ); + + model.schema.register( 'nonListable', { + allowWhere: '$block', + allowContentOf: '$block', + inheritTypesFrom: '$block', + allowAttributes: 'foo' + } ); + + editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); + + // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. + sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); + stubUid(); + } ); + + afterEach( async () => { + await editor.destroy(); + } ); + + describe( 'copy and getSelectedContent()', () => { + it( 'should be able to downcast part of a nested list', () => { + setModelData( model, + 'A' + + '[B1' + + 'B2' + + 'C1]' + + 'C2' + ); + + const modelFragment = model.getSelectedContent( model.document.selection ); + const viewFragment = editor.data.toView( modelFragment ); + const data = editor.data.htmlProcessor.toData( viewFragment ); + + expect( data ).to.equal( + '
      ' + + '
    • ' + + '

      B1

      ' + + '

      B2

      ' + + '
        ' + + '
      • C1
        • ' + + '
      ' + + '
      • ' + + '
    ' + ); + } ); + + it( 'should be able to downcast part of a deep nested list', () => { + setModelData( model, + 'A' + + 'B1' + + 'B2' + + '[C1' + + 'C2]' + ); + + const modelFragment = model.getSelectedContent( model.document.selection ); + const viewFragment = editor.data.toView( modelFragment ); + const data = editor.data.htmlProcessor.toData( viewFragment ); + + expect( data ).to.equal( + '
      ' + + '
    • ' + + '

      C1

      ' + + '

      C2

      ' + + '
      • ' + + '
    ' + ); + } ); + } ); + + describe( 'paste and insertContent() integration', () => { + it( 'should be triggered on DataController#insertContent()', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + editor.model.insertContent( + parseModel( + 'X' + + 'Y', + model.schema + ) + ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BX' + + 'Y[]' + + 'C' + ); + } ); + + it( 'should be triggered when selectable is passed', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + model.insertContent( + parseModel( + 'X' + + 'Y', + model.schema + ), + model.createRange( + model.createPositionFromPath( modelRoot, [ 1, 1 ] ), + model.createPositionFromPath( modelRoot, [ 1, 1 ] ) + ) + ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'B[]X' + + 'Y' + + 'C' + ); + } ); + + // Just checking that it doesn't crash. #69 + it( 'should work if an element is passed to DataController#insertContent()', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + model.change( writer => { + const paragraph = writer.createElement( 'paragraph', { listType: 'bulleted', listItemId: 'x', listIndent: '0' } ); + writer.insertText( 'X', paragraph ); + + model.insertContent( paragraph ); + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BX[]' + + 'C' + ); + } ); + + // Just checking that it doesn't crash. #69 + it( 'should work if an element is passed to DataController#insertContent() - case #69', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + model.change( writer => { + model.insertContent( writer.createText( 'X' ) ); + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BX[]' + + 'C' + ); + } ); + + it( 'should fix indents of pasted list items', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • X
      • Y
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BX' + + 'Y[]' + + 'C' + ); + } ); + + it( 'should not fix indents of list items that are separated by non-list element', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • W
      • X

    Y

    • Z
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BW' + + 'X' + + 'Y' + + 'Z[]' + + 'C' + ); + } ); + + it( 'should co-work correctly with post fixer', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '

    X

    • Y
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BX' + + 'Y[]' + + 'C' + ); + } ); + + it( 'should work if items are pasted between paragraph elements', () => { + // Wrap all changes in one block to avoid post-fixing the selection + // (which may be incorret) in the meantime. + model.change( () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • X
      • Y
    ' ) + } ); + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'B' + + 'X' + + 'Y[]' + + 'C' + ); + } ); + + it( 'should create correct model when list items are pasted in top-level list', () => { + setModelData( model, + 'A[]' + + 'B' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • X
      • Y
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'AX' + + 'Y[]' + + 'B' + ); + } ); + + it( 'should create correct model when list items are pasted in non-list context', () => { + setModelData( model, + 'A[]' + + 'B' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • X
      • Y
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'AX' + + 'Y[]' + + 'B' + ); + } ); + + it( 'should not crash when "empty content" is inserted', () => { + setModelData( model, '[]' ); + + expect( () => { + model.change( writer => { + editor.model.insertContent( writer.createDocumentFragment() ); + } ); + } ).not.to.throw(); + } ); + + it( 'should correctly handle item that is pasted without its parent', () => { + // Wrap all changes in one block to avoid post-fixing the selection + // (which may be incorret) in the meantime. + model.change( () => { + setModelData( model, + 'Foo' + + 'A' + + 'B' + + '[]' + + 'Bar' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
  • X
    • ' ) + } ); + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'Foo' + + 'A' + + 'B' + + 'X[]' + + 'Bar' + ); + } ); + + it( 'should correctly handle item that is pasted without its parent #2', () => { + // Wrap all changes in one block to avoid post-fixing the selection + // (which may be incorret) in the meantime. + model.change( () => { + setModelData( model, + 'Foo' + + 'A' + + 'B' + + '[]' + + 'Bar' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
  • X
    • Y
    • ' ) + } ); + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'Foo' + + 'A' + + 'B' + + 'X' + + 'Y[]' + + 'Bar' + ); + } ); + + it( 'should handle block elements inside pasted list #1', () => { + setModelData( model, + 'A' + + 'B[]' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • W
      • X

        Y

        Z
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'A' + + 'BW' + + 'X' + + 'Y' + + 'Z[]' + + 'C' + ); + } ); + + it( 'should handle block elements inside pasted list #2', () => { + setModelData( model, + 'A[]' + + 'B' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • W
      • X

        Y

        Z
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'AW' + + 'X' + + 'Y' + + 'Z[]' + + 'B' + + 'C' + ); + } ); + + it( 'should handle block elements inside pasted list #3', () => { + setModelData( model, + 'A[]' + + 'B' + + 'C' + ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '

    • W

      X

      Y

    • Z
    ' ) + } ); + + expect( getModelData( model ) ).to.equalMarkup( + 'AW' + + 'X' + + 'Y' + + 'Z[]' + + 'B' + + 'C' + ); + } ); + + it( 'should properly handle split of list items with non-standard converters', () => { + setModelData( model, + 'A[]' + + 'B' + + 'C' + ); + + editor.model.schema.register( 'splitBlock', { allowWhere: '$block' } ); + + editor.conversion.for( 'downcast' ).elementToElement( { model: 'splitBlock', view: 'splitBlock' } ); + editor.conversion.for( 'upcast' ).add( dispatcher => dispatcher.on( 'element:splitBlock', ( evt, data, conversionApi ) => { + const splitBlock = conversionApi.writer.createElement( 'splitBlock' ); + + conversionApi.consumable.consume( data.viewItem, { name: true } ); + conversionApi.safeInsert( splitBlock, data.modelCursor ); + conversionApi.updateConversionResult( splitBlock, data ); + } ) ); + + const clipboard = editor.plugins.get( 'ClipboardPipeline' ); + + clipboard.fire( 'inputTransformation', { + content: parseView( '
    • ab
    ' ) + } ); + + expect( getModelData( model, { withoutSelection: true } ) ).to.equalMarkup( + 'Aa' + + '' + + 'b' + + 'B' + + 'C' + ); + } ); + } ); +} ); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js new file mode 100644 index 00000000000..3d79338694d --- /dev/null +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -0,0 +1,3567 @@ +/** + * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license + */ + +import DocumentListEditing from '../../../src/documentlist/documentlistediting'; + +import BoldEditing from '@ckeditor/ckeditor5-basic-styles/src/bold/boldediting'; +import UndoEditing from '@ckeditor/ckeditor5-undo/src/undoediting'; +import ClipboardPipeline from '@ckeditor/ckeditor5-clipboard/src/clipboardpipeline'; +import BlockQuoteEditing from '@ckeditor/ckeditor5-block-quote/src/blockquoteediting'; +import HeadingEditing from '@ckeditor/ckeditor5-heading/src/headingediting'; +import TableEditing from '@ckeditor/ckeditor5-table/src/tableediting'; +import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph'; +import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; + +import VirtualTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/virtualtesteditor'; +import { + getData as getModelData, + setData as setModelData +} from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; +import { DomEventData } from '@ckeditor/ckeditor5-engine'; + +import stubUid from '../_utils/uid'; +import { modelList } from '../_utils/utils'; +import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubblingeventinfo'; + +describe( 'DocumentListEditing integrations: backspace & delete', () => { + const changedBlocks = []; + + let editor, model, view; + let eventInfo, domEventData; + let mergeBackwardCommand, mergeForwardCommand, splitAfterCommand, indentCommand, + mergeBackwardCommandExecuteSpy, mergeForwardCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; + + testUtils.createSinonSandbox(); + + beforeEach( async () => { + editor = await VirtualTestEditor.create( { + plugins: [ + Paragraph, ClipboardPipeline, BoldEditing, DocumentListEditing, UndoEditing, + BlockQuoteEditing, TableEditing, HeadingEditing + ] + } ); + + model = editor.model; + view = editor.editing.view; + + model.schema.extend( 'paragraph', { + allowAttributes: 'foo' + } ); + + model.schema.register( 'nonListable', { + allowWhere: '$block', + allowContentOf: '$block', + inheritTypesFrom: '$block', + allowAttributes: 'foo' + } ); + + editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); + + // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. + sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); + stubUid(); + + eventInfo = new BubblingEventInfo( view.document, 'delete' ); + + splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); + indentCommand = editor.commands.get( 'outdentList' ); + mergeBackwardCommand = editor.commands.get( 'mergeListItemBackward' ); + mergeForwardCommand = editor.commands.get( 'mergeListItemForward' ); + + splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); + outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); + mergeBackwardCommandExecuteSpy = sinon.spy( mergeBackwardCommand, 'execute' ); + mergeForwardCommandExecuteSpy = sinon.spy( mergeForwardCommand, 'execute' ); + + changedBlocks.length = 0; + + splitAfterCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + indentCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + mergeBackwardCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + mergeForwardCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + } ); + + afterEach( async () => { + await editor.destroy(); + } ); + + describe( 'backspace (backward)', () => { + beforeEach( () => { + domEventData = new DomEventData( view, { + preventDefault: sinon.spy() + }, { + direction: 'backward', + unit: 'codePoint', + sequence: 1 + } ); + } ); + + describe( 'single block list item', () => { + describe( 'collapsed selection at the beginning of a list item', () => { + describe( 'item before is empty', () => { + it( 'should remove list when in empty only element of a list', () => { + setModelData( model, modelList( [ + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + } ); + + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* ', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b {id:001}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented empty list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge empty list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should keep merged list item\'s children', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* ', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:001}' + ] ) ); + } ); + + // Default behaviour of backspace? + it( 'should merge empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}' + ] ) ); + } ); + + it( 'should merge indented empty list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge non empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + } ); + + it( 'should merge empty list item with with previous list item as a block', () => { + setModelData( model, modelList( [ + '* a', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + } ); + + it( 'should merge indented list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b' + ] ) ); + } ); + + it( 'should merge indented empty list item with with parent list item as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []' + ] ) ); + } ); + + it( 'should merge list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c' + ] ) ); + } ); + + it( 'should merge empty list item with with previous list item with higher indent as a block', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []' + ] ) ); + } ); + + it( 'should keep merged list item\'s children', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + } ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + 'a', + '* [', + '* ]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a', + '* []' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther{id:001}' + ] ) ); + } ); + + it( 'should merge two list items if selection is in the middle', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* text[', + '* ]another' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]another' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* text[', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]ther' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]', + '* b {id:002}', + ' * c{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]c', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]e' + ] ) ); + } ); + } ); + } ); + } ); + + describe( 'multi-block list item', () => { + describe( 'collapsed selection at the beginning of a list item', () => { + describe( 'item before is empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* ', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b{id:001}', + ' c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it.skip( 'should merge with previous list item and keep complex blocks intact ', () => { + setModelData( model, modelList( [ + '* ', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with first block empty with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + '* []', + ' a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' a' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []a', + ' b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented empty list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge empty list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* ', + ' * ', + '* []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'item before is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge block to a previous list item', () => { + setModelData( model, modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' []d', + ' e' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact', () => { + setModelData( model, modelList( [ + '* a', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge list item with first block empty with previous list item', () => { + setModelData( model, modelList( [ + '* a', + '* []', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list item with with previous list item as blocks', () => { + setModelData( model, modelList( [ + '* a', + ' * []a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []a', + ' b' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + + // expect( changedBlocks ).to.deep.equal( [ + // modelRoot.getChild( 0 ) + // ] ); + } ); + + it( 'should merge indented list having block and indented list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []b', + ' c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []b', + ' c', + ' * d' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented empty list item with previous list item', () => { + setModelData( model, modelList( [ + '* a', + ' * []', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' text' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with with previous indented empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + '* []c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' []c', + ' d' + ] ) ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'collapsed selection in the middle of the list item', () => { + it( 'should merge block to a previous list item', () => { + setModelData( model, modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ] ) ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + '* [', + '* ]', + ' ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' ' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:004}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list itemxx', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' ]c', + ' * d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* c', + ' * d {id:003}', + ' e' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge middle block with following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d{id:001}', + ' * e{id:003}', + ' f' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' cd]', + ' * e', + ' f', + ' s' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' * e {id:003}', + ' f', + '* s {id:001}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther{id:001}', + ' text' + ] ) ); + } ); + + // Not related to merge command + it( 'should merge two list items with selection in the middle', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}', + ' * c {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' c', + ' * d {id:004}', + ' e', + '* f {id:001}', + ' g' + ] ) ); + } ); + } ); + } ); + } ); + + describe( 'selection outside list', () => { + describe( 'collapsed selection', () => { + it( 'no list editing commands should be executed outside list (empty paragraph)', () => { + setModelData( model, + '[]' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + '[]' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed outside list (selection at the beginning of text)', () => { + setModelData( model, + '[]text' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + '[]text' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed outside list (selection at the end of text)', () => { + setModelData( model, + 'text[]' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + 'tex[]' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed outside list (selection in the middle of text)', () => { + setModelData( model, + 'te[]xt' + ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( + 't[]xt' + ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed next to a list', () => { + setModelData( model, modelList( [ + '1[]', + '* 2' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]', + '* 2' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when merging two lists', () => { + setModelData( model, modelList( [ + '* 1', + '[]2', + '* 3' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* 1[]2', + '* 3 {id:002}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when merging two lists - one nested', () => { + setModelData( model, modelList( [ + '* 1', + '[]2', + '* 3', + ' * 4' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* 1[]2', + '* 3 {id:002}', + ' * 4 {id:003}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'empty list should be deleted', () => { + setModelData( model, modelList( [ + '* ', + '[]2', + '* 3' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]2', + '* 3 {id:002}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + } ); + + describe( 'non-collapsed selection', () => { + describe( 'outside list', () => { + it( 'no list editing commands should be executed', () => { + setModelData( model, modelList( [ + 't[ex]t' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 't[]t' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when outside list when next to a list', () => { + setModelData( model, modelList( [ + 't[ex]t', + '* 1' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 't[]t', + '* 1' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + } ); + + describe( 'only start in a list', () => { + it( 'no list editing commands should be executed when doing delete', () => { + setModelData( model, modelList( [ + '* te[xt', + 'aa]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'no list editing commands should be executed when doing delete (multi-block list)', () => { + setModelData( model, modelList( [ + '* te[xt1', + ' text2', + ' * text3', + 'text4]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]' + ] ) ); + + expect( changedBlocks ).to.be.empty; + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + } ); + + it( 'should delete everything till end of selection and merge remaining text', () => { + setModelData( model, modelList( [ + '* text1', + ' tex[t2', + ' * text3', + 'tex]t4' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text1', + ' tex[]t4' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + } ); + + describe( 'only end in a list', () => { + it( 'should delete everything till end of selection', () => { + setModelData( model, modelList( [ + '[', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt {id:001}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should delete everything till the end of selection and adjust remaining block to item list', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should delete everything till the end of selection and adjust remaining item list indentation', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c {id:002}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should delete selection and adjust remaining item list indentation (multi-block)', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' * c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c {id:002}', + ' d' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + // TODO: skipped because below TODO + it.skip( 'should remove selection and adjust remaining list', () => { + setModelData( model, modelList( [ + 'a[', + '* b]b', + ' * c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]b', + '* c', + ' d' // TODO: No way currently to adjust this block id <- + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should remove selection and adjust remaining list (multi-block)', () => { + setModelData( model, modelList( [ + 'a[', + '* b', + ' * c', + ' d]d', + ' * e', + ' f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a[]d', + '* e {id:004}', + ' f' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + } ); + + describe( 'spanning multiple lists', () => { + it( 'should merge lists into one with one list item', () => { + setModelData( model, modelList( [ + '* a[a', + 'b', + '* c]c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]c' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge lists into one with two blocks', () => { + setModelData( model, modelList( [ + '* a', + ' b[b', + 'c', + '* d]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]d' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with two list items', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d]', + '* e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]', + '* e {id:003}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with two list items (multiple blocks)', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d]', + ' e', + '* f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]', + ' e', + '* f {id:004}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with two list items and adjust indentation', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]e', + ' * f {id:004}', + ' g' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with deeper indendation', () => { + setModelData( model, modelList( [ + '* a', + ' * b[', + 'c', + '* d', + ' * e', + ' * f]f', + ' * g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]f', + ' * g {id:006}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one with deeper indentation (multiple blocks)', () => { + setModelData( model, modelList( [ + '* a', + ' * b[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]e', + ' * f {id:005}', + ' g' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge two lists into one and keep items after selection', () => { + setModelData( model, modelList( [ + '* a[', + 'c', + '* d', + ' * e]e', + '* f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]e', + '* f {id:004}', + ' g' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge lists of different types to a single list and keep item lists types', () => { + setModelData( model, modelList( [ + '* a', + '* b[b', + 'c', + '# d]d', + '# d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* b[]d', + '# d {id:004}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + + it( 'should merge lists of mixed types to a single list and keep item lists types', () => { + setModelData( model, modelList( [ + '* a', + '# b[b', + 'c', + '# d]d', + ' * f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '# b[]d', + ' * f {id:004}' + ] ) ); + + expect( changedBlocks ).to.be.empty; + } ); + } ); + } ); + } ); + } ); + + describe( 'delete (forward)', () => { + beforeEach( () => { + domEventData = new DomEventData( view, { + preventDefault: sinon.spy() + }, { + direction: 'forward', + unit: 'codePoint', + sequence: 1 + } ); + } ); + + describe( 'single block list item', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it.skip( 'should remove list when in empty only element of a list', () => { + setModelData( model, modelList( [ + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + } ); + + it( 'should remove next empty list item', () => { + setModelData( model, modelList( [ + '* b[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b[]' + ] ) ); + + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove next empty list item when current is empty', () => { + setModelData( model, modelList( [ + '* []', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove current list item if empty and replace with indented', () => { + setModelData( model, modelList( [ + '* []', + ' * a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + sinon.assert.calledOnce( mergeForwardCommandExecuteSpy ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}' + ] ) ); + + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove next empty indented item list', () => { + setModelData( model, modelList( [ + '* []', + ' * ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should replace current empty list item with next list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a{id:002}' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove next empty list item when current is also empty', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'next list item is not empty', () => { + it( 'should merge text from next list item with current list item text', () => { + setModelData( model, modelList( [ + '* a[]', + '* b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should delete next empty item list', () => { + setModelData( model, modelList( [ + '* a[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge text of indented list item with current list item', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should remove indented empty list item', () => { + setModelData( model, modelList( [ + '* a[]', + ' * ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge text of lower indent list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b[]', + '* c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]c' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should delete next empty list item with lower ident', () => { + setModelData( model, modelList( [ + '* a', + ' * b[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge following item list of first block and adjust it\'s children', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + ' * c {id:002}', + ' * d {id:003}', + ' e', + ' * f {id:005}', + ' * g {id:006}', + ' h' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge following first block of an item list and make second block a first one', () => { + setModelData( model, modelList( [ + '* a[]', + ' * b', + ' b2', + ' * c', + ' * d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + ' b2', + ' * c {id:003}', + ' * d {id:004}', + ' e' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + 'a', + '* [', + '* ]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'a', + '* []' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text{id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []{id:000}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther{id:001}' + ] ) ); + } ); + + it( 'should merge two list items if selection starts in the middle of text', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* text[', + '* ]another' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]another' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* text[', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]ther' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]', + '* b {id:002}', + ' * c {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]c', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[] {id:000}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + // output is okay, fix expect + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* text[', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* text[]e' + ] ) ); + } ); + } ); + } ); + } ); + + describe( 'multi-block list item', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it( 'should remove empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' b[]', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it.skip( 'should merge following complex list item with current one', () => { + setModelData( model, modelList( [ + '* ', + ' []', + '* b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' []b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge and remove block of same list item', () => { + setModelData( model, modelList( [ + '* []', + ' a' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list item with with currently selected list item', () => { + setModelData( model, modelList( [ + '* []', + ' * a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a{id:001}', + ' b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + setModelData( model, modelList( [ + '* []', + ' * a', + ' b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented list item with first block empty', () => { + setModelData( model, modelList( [ + '* []', + ' * ', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' text' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge next outdented list item', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []a {id:002}', + ' b' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge next outdented list item with first block empty', () => { + setModelData( model, modelList( [ + '* ', + ' * []', + '* ', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' * []', + ' text' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'list item after is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + setModelData( model, modelList( [ + '* a[]', + '* b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a[]b', + ' c' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge all following outdented blocks', () => { + setModelData( model, modelList( [ + '* b', + ' * c', + ' c2[]', + ' d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* b', + ' * c', + ' c2[]d', + ' e' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge complex list item', () => { + setModelData( model, modelList( [ + '* a', + ' a2[]', + '* b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' a2[]b', + ' c', + ' * d {id:004}', + ' e', + ' * f {id:006}', + ' * g {id:007}', + ' h', + ' * i {id:009}', + ' * j {id:010}', + ' k', + ' l' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with next multi-block list item', () => { + setModelData( model, modelList( [ + '* a', + ' a2[]', + '* b', + ' b2' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' a2[]b', + ' b2' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge outdented multi-block list item', () => { + setModelData( model, modelList( [ + '* a', + ' a2[]', + ' * b', + ' b2' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' a2[]b', + ' b2' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge an outdented list item in an outdented list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + ' c[]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' c[]d' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge indented empty list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b', + ' c[]', + ' * ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b', + ' c[]' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should merge list item with with next outdented list item', () => { + setModelData( model, modelList( [ + '* a', + ' * b[]', + '* c', + ' d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * b[]c', + ' d' + ] ) ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'collapsed selection in the middle of the list item', () => { + it( 'should merge next indented list item', () => { + setModelData( model, modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]', + ' # Z', + ' V', + '* E', + '* F' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]Z', + ' V', + '* E {id:007}', + '* F {id:008}' + ] ) ); + } ); + } ); + + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + setModelData( model, modelList( [ + '* [', + '* ]', + ' ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' ' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text {id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt {id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c {id:002}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* [] {id:000}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e {id:004}' + ] ) ); + } ); + + it( 'should delete all following items till the end of selection and merge last list itemxx', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' ]c', + ' * d', + ' e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* c', + ' * d {id:003}', + ' e' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge middle block with following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []d {id:001}', + ' * e {id:003}', + ' f' + ] ) ); + } ); + + it( 'should delete items till the end of selection and merge following blocks', () => { + setModelData( model, modelList( [ + '* [', + ' * b', + ' cd]', + ' * e', + ' f', + ' s' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' * e {id:003}', + ' f', + '* s {id:001}' + ] ) ); + } ); + } ); + + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + setModelData( model, modelList( [ + '* [text', + '* ano]ther', + ' text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []ther {id:001}', + ' text' + ] ) ); + } ); + + // Not related to merge command + it( 'should merge two list items with selection in the middle', () => { + setModelData( model, modelList( [ + '* te[xt', + '* ano]ther' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* te[]ther' + ] ) ); + } ); + + it( 'should merge non empty list item', () => { + setModelData( model, modelList( [ + '* [', + '* ]text' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []text {id:001}' + ] ) ); + } ); + + it( 'should merge non empty list item and delete text', () => { + setModelData( model, modelList( [ + '* [', + '* te]xt' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []xt{id:001}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * ]b', + ' * c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:002}', + ' * c {id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]c', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []c{id:002}', + ' * d{id:003}' + ] ) ); + } ); + + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * bc]', + ' * d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* [] {id:000}', + ' * d {id:003}' + ] ) ); + } ); + + it( 'should delete all items till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* ]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* d {id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and merge last list item', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b', + '* d]e' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []e{id:003}' + ] ) ); + } ); + + it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { + setModelData( model, modelList( [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f', + ' g' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' c', + ' * d {id:004}', + ' e', + '* f {id:001}', + ' g' + ] ) ); + } ); + } ); + } ); + } ); + } ); +} ); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/enter.js b/packages/ckeditor5-list/tests/documentlist/integrations/enter.js new file mode 100644 index 00000000000..96c0fb45668 --- /dev/null +++ b/packages/ckeditor5-list/tests/documentlist/integrations/enter.js @@ -0,0 +1,1340 @@ +/** + * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license + */ + +import DocumentListEditing from '../../../src/documentlist/documentlistediting'; + +import BoldEditing from '@ckeditor/ckeditor5-basic-styles/src/bold/boldediting'; +import UndoEditing from '@ckeditor/ckeditor5-undo/src/undoediting'; +import ClipboardPipeline from '@ckeditor/ckeditor5-clipboard/src/clipboardpipeline'; +import BlockQuoteEditing from '@ckeditor/ckeditor5-block-quote/src/blockquoteediting'; +import HeadingEditing from '@ckeditor/ckeditor5-heading/src/headingediting'; +import TableEditing from '@ckeditor/ckeditor5-table/src/tableediting'; +import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph'; +import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; +import EventInfo from '@ckeditor/ckeditor5-utils/src/eventinfo'; + +import VirtualTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/virtualtesteditor'; +import { + getData as getModelData, + setData as setModelData +} from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; +import { DomEventData } from '@ckeditor/ckeditor5-engine'; + +import stubUid from '../_utils/uid'; +import { modelList } from '../_utils/utils'; + +describe( 'DocumentListEditing integrations: enter key', () => { + const changedBlocks = []; + + let editor, model, modelDoc, modelRoot, view; + let eventInfo, domEventData; + let splitBeforeCommand, splitAfterCommand, indentCommand, + splitBeforeCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; + + testUtils.createSinonSandbox(); + + beforeEach( async () => { + editor = await VirtualTestEditor.create( { + plugins: [ + Paragraph, ClipboardPipeline, BoldEditing, DocumentListEditing, UndoEditing, + BlockQuoteEditing, TableEditing, HeadingEditing + ] + } ); + + model = editor.model; + modelDoc = model.document; + modelRoot = modelDoc.getRoot(); + + view = editor.editing.view; + + model.schema.extend( 'paragraph', { + allowAttributes: 'foo' + } ); + + model.schema.register( 'nonListable', { + allowWhere: '$block', + allowContentOf: '$block', + inheritTypesFrom: '$block', + allowAttributes: 'foo' + } ); + + editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); + + // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. + sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); + stubUid(); + + eventInfo = new EventInfo( view.document, 'enter' ); + domEventData = new DomEventData( view.document, { + preventDefault: sinon.spy() + } ); + + splitBeforeCommand = editor.commands.get( 'splitListItemBefore' ); + splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); + indentCommand = editor.commands.get( 'outdentList' ); + + splitBeforeCommandExecuteSpy = sinon.spy( splitBeforeCommand, 'execute' ); + splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); + outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); + + changedBlocks.length = 0; + + splitBeforeCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + splitAfterCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + + indentCommand.on( 'afterExecute', ( evt, data ) => { + changedBlocks.push( ...data ); + } ); + } ); + + afterEach( async () => { + await editor.destroy(); + } ); + + describe( 'collapsed selection', () => { + describe( 'with just one block per list item', () => { + it( 'should outdent if the slection in the only empty list item (convert into paragraph and turn off the list)', () => { + setModelData( model, modelList( [ + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 0 ) + ] ); + + sinon.assert.calledOnce( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should outdent if the slection in the last empty list item (convert the item into paragraph)', () => { + setModelData( model, modelList( [ + '* a', + '* []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '[]' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.calledOnce( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another list item when the selection in a non-empty only list item', () => { + setModelData( model, modelList( [ + '* a[]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* [] {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should outdent if the selection in an empty, last sub-list item', () => { + setModelData( model, modelList( [ + '* a', + ' # b', + ' * c', + ' * []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' # b', + ' * c', + ' # []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 3 ) + ] ); + + sinon.assert.calledOnce( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + + describe( 'with multiple blocks in a list item', () => { + it( 'should outdent if the selection is anchored in an empty, last item block', () => { + setModelData( model, modelList( [ + '* a', + ' # b', + ' # []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' # b', + '* []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 2 ) + ] ); + + sinon.assert.calledOnce( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should outdent if the selection is anchored in an empty, only sub-item block', () => { + setModelData( model, modelList( [ + '* a', + ' # b', + ' * []', + ' #' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' # b', + ' # []', + ' #' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 2 ) + ] ); + + sinon.assert.calledOnce( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another block when the selection at the start of a non-empty first block', () => { + setModelData( model, modelList( [ + '* a[]', + ' b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' []', + ' b', + ' c' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should create another block when the selection at the end of a non-empty first block', () => { + setModelData( model, modelList( [ + '* []a', + ' b', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + ' []a', + ' b', + ' c' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should create another block when the selection at the start of a non-empty last block', () => { + setModelData( model, modelList( [ + '* a', + ' b', + ' []c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b', + ' ', + ' []c' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should create another block when the selection at the end of a non-empty last block', () => { + setModelData( model, modelList( [ + '* a', + ' b', + ' c[]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b', + ' c', + ' []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should create another block when the selection in an empty middle block', () => { + setModelData( model, modelList( [ + '* a', + ' []', + ' c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' ', + ' []', + ' c' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should create another list item when the selection in an empty last block (two blocks in total)', () => { + setModelData( model, modelList( [ + '* a', + ' []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* [] {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another list item when the selection in an empty last block (three blocks in total)', () => { + setModelData( model, modelList( [ + '* a', + ' b', + ' []' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b', + '* [] {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 2 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another list item when the selection in an empty last block (followed by a list item)', () => { + setModelData( model, modelList( [ + '* a', + ' b', + ' []', + '* ' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' b', + '* [] {id:a00}', + '* ' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 2 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another list item when the selection in an empty first block (followed by another block)', () => { + setModelData( model, modelList( [ + '* []', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* b {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.calledOnce( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another list item when the selection in an empty first block (followed by multiple blocks)', () => { + setModelData( model, modelList( [ + '* []', + ' a', + ' b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* a {id:a00}', + ' b' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ), + modelRoot.getChild( 2 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.calledOnce( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + + it( 'should create another list item when the selection in an empty first block (followed by multiple blocks and an item)', + () => { + setModelData( model, modelList( [ + '* []', + ' a', + ' b', + '* c' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* a {id:a00}', + ' b', + '* c' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ), + modelRoot.getChild( 2 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.calledOnce( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.true; + } ); + } ); + } ); + + describe( 'non-collapsed selection', () => { + describe( 'with just one block per list item', () => { + it( 'should create another list item if the selection contains some content at the end of the list item', () => { + setModelData( model, modelList( [ + '* a[b]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* [] {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should create another list item if the selection contains some content at the start of the list item', () => { + setModelData( model, modelList( [ + '* [a]b' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + '* []b {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content and turn off the list if slection contains all content at the zero indent level', () => { + setModelData( model, modelList( [ + '* [a', + '* b]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content and move the selection when it contains some content at the zero indent level', () => { + setModelData( model, modelList( [ + '* a[b', + '* b]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content when the selection contains all content at a deeper indent level', () => { + setModelData( model, modelList( [ + '* a', + ' # b', + ' * [c', + ' * d]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' # b', + ' * []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + describe( 'cross-indent level selection', () => { + it( 'should clean the content and remove list across different indentation levels (list the only content)', () => { + setModelData( model, modelList( [ + '* [ab', + ' # cd]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (one level, entire blocks)', () => { + setModelData( model, modelList( [ + 'foo', + '* [ab', + ' # cd]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'foo', + '* []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (one level, subset of blocks)', () => { + setModelData( model, modelList( [ + 'foo', + '* a[b', + ' # c]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'foo', + '* a', + ' # []d' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (two levels, entire blocks)', () => { + setModelData( model, modelList( [ + '* [ab', + ' # cd', + ' * ef]', + ' * gh' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + ' * gh {id:003}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (two levels, subset of blocks)', () => { + setModelData( model, modelList( [ + '* a[b', + ' # cd', + ' * e]f', + ' * gh' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' * []f {id:002}', + ' * gh {id:003}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (three levels, entire blocks)', () => { + setModelData( model, modelList( [ + 'foo', + '* [ab', + ' # cd', + ' * ef', + ' * gh]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'foo', + '* []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content and remove list across different indentation levels ' + + '(three levels, list the only content)', () => { + setModelData( model, modelList( [ + '* [ab', + ' # cd', + ' * ef', + ' * gh]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '[]' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (three levels, subset of blocks)', () => { + setModelData( model, modelList( [ + '* a[b', + ' # cd', + ' * ef', + ' # g]h', + ' * ij' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + ' # []h {id:003}', + '* ij {id:004}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (one level, start at first, entire blocks)', () => { + setModelData( model, modelList( [ + '* ab', + ' # [cd', + ' * ef', + ' * gh]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' # []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (one level, start at first, part of blocks)', () => { + setModelData( model, modelList( [ + '* ab', + ' # c[d', + ' * ef', + ' * g]h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' # c', + ' * []h {id:003}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (level up then down, subset of blocks)', () => { + setModelData( model, modelList( [ + '* ab', + ' # c[d', + ' * ef', + ' # g]h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' # c', + ' # []h {id:003}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (level up then down, entire of blocks)', () => { + setModelData( model, modelList( [ + '* ab', + ' # [cd', + ' * ef', + ' # gh]', + '* ij' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' # []', + '* ij {id:004}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the content across different indentation levels (level up then down, preceded by an item)', () => { + setModelData( model, modelList( [ + '* ab', + ' # cd', + ' # [ef', + ' * gh', + ' # ij]', + '* kl' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' # cd', + ' # []', + '* kl {id:005}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + } ); + } ); + + describe( 'with multiple blocks in a list item', () => { + it( 'should clean the selected content (partial blocks)', () => { + setModelData( model, modelList( [ + '* a[b', + ' c]d' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* a', + '* []d {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (entire blocks)', () => { + setModelData( model, modelList( [ + 'foo', + '* [ab', + ' cd]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'foo', + '* []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (entire block, middle one)', () => { + setModelData( model, modelList( [ + '* ab', + ' [cd]', + ' ef' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' []', + ' ef' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (entire blocks, starting from the second)', () => { + setModelData( model, modelList( [ + '* ab', + ' [cd', + ' ef]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + // Generally speaking, we'd rather expect something like this: + // * ab + // [] + // But there is no easy way to tell what the original selection looked like when it came to EnterCommand#afterExecute. + // Enter deletes all the content first [cd, ef] and in #afterExecute it looks like the original selection was: + // * ab + // [] + // and the algorithm falls back to splitting in this case. There's even a test for this kind of selection. + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + '* [] {id:a00}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [ + modelRoot.getChild( 1 ) + ] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.calledOnce( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (partial blocks, starting from the second)', () => { + setModelData( model, modelList( [ + '* ab', + ' c[d', + ' e]f' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' c', + ' []f' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (entire blocks, three blocks in total)', () => { + setModelData( model, modelList( [ + '* [ab', + ' cd', + ' ef]', + '* gh' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* []', + '* gh {id:003}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (entire blocks, across list items)', () => { + setModelData( model, modelList( [ + 'foo', + '* [ab', + ' cd', + ' ef', + '* gh]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + 'foo', + '* []' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (entire blocks + a partial block, across list items)', () => { + setModelData( model, modelList( [ + '* [ab', + ' cd', + ' ef', + '* g]h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ', + '* []h {id:003}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (partial blocks, across list items)', () => { + setModelData( model, modelList( [ + '* ab', + ' cd', + ' e[f', + '* g]h' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' cd', + ' e', + '* []h' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + describe( 'cross-indent level selection', () => { + it( 'should clean the selected content (partial blocks)', () => { + setModelData( model, modelList( [ + '* ab', + ' * cd', + ' e[f', + ' gh', + ' * i]j' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' * cd', + ' e', + ' * []j {id:004}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (partial blocks + entire block)', () => { + setModelData( model, modelList( [ + '* ab', + ' * cd', + ' e[f', + ' gh', + ' * ij]' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' * cd', + ' e', + ' * [] {id:004}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + + it( 'should clean the selected content (across two middle levels)', () => { + setModelData( model, modelList( [ + '* ab', + ' c[d', + ' * ef', + ' g]h', + ' * ij' + ] ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( [ + '* ab', + ' c', + ' * []h', + ' * ij {id:004}' + ] ) ); + + expect( changedBlocks ).to.deep.equal( [] ); + + sinon.assert.notCalled( outdentCommandExecuteSpy ); + sinon.assert.notCalled( splitBeforeCommandExecuteSpy ); + sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + + sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); + expect( eventInfo.stop.called ).to.be.undefined; + } ); + } ); + } ); + } ); +} ); From 1f1173b224c861784c5752f3d4081d25ebc3473d Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 25 Jan 2022 16:03:49 +0100 Subject: [PATCH 19/44] Code refactoring in delete/backspace tests. --- .../tests/documentlist/integrations/delete.js | 6581 ++++++++++------- 1 file changed, 3756 insertions(+), 2825 deletions(-) diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 3d79338694d..93fe9044c7e 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -26,11 +26,12 @@ import { modelList } from '../_utils/utils'; import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubblingeventinfo'; describe( 'DocumentListEditing integrations: backspace & delete', () => { - const changedBlocks = []; + const blocksChangedByCommands = []; let editor, model, view; let eventInfo, domEventData; - let mergeBackwardCommand, mergeForwardCommand, splitAfterCommand, indentCommand, + let mergeBackwardCommand, mergeForwardCommand, splitAfterCommand, outdentCommand, + commandSpies, mergeBackwardCommandExecuteSpy, mergeForwardCommandExecuteSpy, splitAfterCommandExecuteSpy, outdentCommandExecuteSpy; testUtils.createSinonSandbox(); @@ -45,6 +46,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { model = editor.model; view = editor.editing.view; + // modelRoot = model.document.getRoot(); model.schema.extend( 'paragraph', { allowAttributes: 'foo' @@ -66,31 +68,38 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { eventInfo = new BubblingEventInfo( view.document, 'delete' ); splitAfterCommand = editor.commands.get( 'splitListItemAfter' ); - indentCommand = editor.commands.get( 'outdentList' ); + outdentCommand = editor.commands.get( 'outdentList' ); mergeBackwardCommand = editor.commands.get( 'mergeListItemBackward' ); mergeForwardCommand = editor.commands.get( 'mergeListItemForward' ); splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); - outdentCommandExecuteSpy = sinon.spy( indentCommand, 'execute' ); + outdentCommandExecuteSpy = sinon.spy( outdentCommand, 'execute' ); mergeBackwardCommandExecuteSpy = sinon.spy( mergeBackwardCommand, 'execute' ); mergeForwardCommandExecuteSpy = sinon.spy( mergeForwardCommand, 'execute' ); - changedBlocks.length = 0; + commandSpies = { + outdent: outdentCommandExecuteSpy, + splitAfter: splitAfterCommandExecuteSpy, + mergeBackward: mergeBackwardCommandExecuteSpy, + mergeForward: mergeForwardCommandExecuteSpy + }; - splitAfterCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); + blocksChangedByCommands.length = 0; + + outdentCommand.on( 'afterExecute', ( evt, data ) => { + blocksChangedByCommands.push( ...data ); } ); - indentCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); + splitAfterCommand.on( 'afterExecute', ( evt, data ) => { + blocksChangedByCommands.push( ...data ); } ); mergeBackwardCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); + blocksChangedByCommands.push( ...data ); } ); mergeForwardCommand.on( 'afterExecute', ( evt, data ) => { - changedBlocks.push( ...data ); + blocksChangedByCommands.push( ...data ); } ); } ); @@ -113,304 +122,311 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { it( 'should remove list when in empty only element of a list', () => { - setModelData( model, modelList( [ - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); + runTest( { + input: [ + '* []' + ], + expected: [ + '[]' + ], + eventStopped: true, + executedCommands: { + outdent: 1, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [ 0 ] + } ); } ); it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b {id:001}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + '* []b' + ], + expected: [ + '* []b {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0, 1 ] + } ); } ); it( 'should merge empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + '* []' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * []a' + ], + expected: [ + '* []a {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0 ] + } ); } ); it( 'should merge indented empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * []' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * ', + '* []a' + ], + expected: [ + '* ', + ' * []a{id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1, 2 ] + } ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * ', + '* []' + ], + expected: [ + '* ', + ' * []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); } ); describe( 'item before is not empty', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + '* []b' + ], + expected: [ + '* a', + ' []b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + '* []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * []b' + ], + expected: [ + '* a', + ' []b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b', + '* []c' + ], + expected: [ + '* a', + ' * b', + ' []c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b', + '* []' + ], + expected: [ + '* a', + ' * b', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); it( 'should keep merged list item\'s children', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + expected: [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1, 2, 3, 4, 5, 6, 7 ] + } ); } ); } ); } ); @@ -418,202 +434,293 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'collapsed selection at the end of a list item', () => { describe( 'item after is empty', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}' - ] ) ); + runTest( { + input: [ + '* ', + '* []b' + ], + expected: [ + '* []b{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); // Default behaviour of backspace? it( 'should merge empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* ', + '* []' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}' - ] ) ); + runTest( { + input: [ + '* ', + ' * []a' + ], + expected: [ + '* []a {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* ', + ' * []' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); + runTest( { + input: [ + '* ', + ' * ', + '* []a' + ], + expected: [ + '* ', + ' * []a{id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); + runTest( { + input: [ + '* ', + ' * ', + '* []' + ], + expected: [ + '* ', + ' * []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); } ); describe( 'item before is not empty', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); + runTest( { + input: [ + '* a', + '* []b' + ], + expected: [ + '* a', + ' []b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge empty list item with with previous list item as a block', () => { - setModelData( model, modelList( [ - '* a', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + '* []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); + runTest( { + input: [ + '* a', + ' * []b' + ], + expected: [ + '* a', + ' []b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item with with parent list item as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); + runTest( { + input: [ + '* a', + ' * b', + '* []c' + ], + expected: [ + '* a', + ' * b', + ' []c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + ' * b', + '* []' + ], + expected: [ + '* a', + ' * b', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); } ); it( 'should keep merged list item\'s children', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); + runTest( { + input: [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + expected: [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1, 2, 3, 4, 5, 6, 7 ] + } ); } ); } ); } ); @@ -621,257 +728,375 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'non-collapsed selection starting in first block of a list item', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - 'a', - '* [', - '* ]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a', - '* []' - ] ) ); + runTest( { + input: [ + 'a', + '* [', + '* ]' + ], + expected: [ + 'a', + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 2 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + expected: [ + '* []text{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + expected: [ + '* []xt{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b' + ], + expected: [ + '* []', + '* b {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1, 2 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* []{id:000}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1, 2, 3 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* []', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1, 2 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1, 2 ] + } ); } ); } ); describe( 'first position in non-empty block', () => { it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}' - ] ) ); + runTest( { + input: [ + '* [text', + '* ano]ther' + ], + expected: [ + '* []ther{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two list items if selection is in the middle', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); + runTest( { + input: [ + '* te[xt', + '* ano]ther' + ], + expected: [ + '* te[]ther' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* text[', - '* ]another' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]another' - ] ) ); + runTest( { + input: [ + '* text[', + '* ]another' + ], + expected: [ + '* text[]another' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* text[', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]ther' - ] ) ); + runTest( { + input: [ + '* text[', + '* ano]ther' + ], + expected: [ + '* text[]ther' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* b {id:002}', - ' * c{id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * ]b', + ' * c' + ], + expected: [ + '* text[]', + '* b {id:002}', + ' * c{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]c', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* text[]c', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* text[]{id:000}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* text[]', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]e' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* text[]e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); @@ -881,840 +1106,961 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* ', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - } ); - - it.skip( 'should merge with previous list item and keep complex blocks intact ', () => { - setModelData( model, modelList( [ - '* ', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* ', + '* []b', + ' c' + ], + expected: [ + '* []b{id:001}', + ' c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact ', () => { + runTest( { + input: [ + '* ', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + expected: [ + '* []b {id:001}', + ' c', + ' * d {id:003}', + ' e', + ' * f {id:005}', + ' * g {id:006}', + ' h', + ' * i {id:008}', + ' * j {id:009}', + ' k', + ' l' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] + } ); } ); it( 'should merge list item with first block empty with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - '* []', - ' a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' a' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* ', + '* []', + ' a' + ], + expected: [ + '* []', + ' a' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0 ] + } ); } ); it( 'should merge indented list item with with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* ', + ' * []a', + ' b' + ], + expected: [ + '* []a {id:001}', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0, 1, 2 ] + } ); } ); it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []a', - ' b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b', - ' * c {id:003}' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* ', + ' * []a', + ' b', + ' * c' + ], + expected: [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0, 1, 2, 3 ] + } ); } ); it( 'should merge indented empty list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* ', + ' * []', + ' text' + ], + expected: [ + '* []', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 0, 1, 2 ] + } ); } ); it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * ', + '* []a', + ' b' + ], + expected: [ + '* ', + ' * []a{id:002}', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2, 3 ] + } ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* ', - ' * ', - '* []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * ', + '* []', + ' text' + ], + expected: [ + '* ', + ' * []', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'item before is not empty', () => { it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* a', - '* []b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* a', + '* []b', + ' c' + ], + expected: [ + '* a', + ' []b', + ' c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge block to a previous list item', () => { - setModelData( model, modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* b', + ' * c', + ' []d', + ' e' + ], + expected: [ + '* b', + ' * c', + ' []d', + ' e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge with previous list item and keep complex blocks intact', () => { - setModelData( model, modelList( [ - '* a', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* a', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + expected: [ + '* a', + ' []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with first block empty with previous list item', () => { - setModelData( model, modelList( [ - '* a', - '* []', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* a', + '* []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with previous list item as blocks', () => { - setModelData( model, modelList( [ - '* a', - ' * []a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []a', - ' b' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; - - // expect( changedBlocks ).to.deep.equal( [ - // modelRoot.getChild( 0 ) - // ] ); + runTest( { + input: [ + '* a', + ' * []a', + ' b' + ], + expected: [ + '* a', + ' []a', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list having block and indented list item with previous list item', () => { - setModelData( model, modelList( [ - '* a', - ' * []b', - ' c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * []b', + ' c', + ' * d' + ], + expected: [ + '* a', + ' []b', + ' c', + ' * d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item with previous list item', () => { - setModelData( model, modelList( [ - '* a', - ' * []', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' text' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * []', + ' text' + ], + expected: [ + '* a', + ' []', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous indented empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - '* []c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c', - ' d' - ] ) ); - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); - sinon.assert.calledOnce( mergeBackwardCommandExecuteSpy ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b', + '* []c', + ' d' + ], + expected: [ + '* a', + ' * b', + ' []c', + ' d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); describe( 'collapsed selection in the middle of the list item', () => { it( 'should merge block to a previous list item', () => { - setModelData( model, modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' []X', - ' # Z', - ' V', - '* E', - '* F' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' []X', - ' # Z', - ' V', - '* E', - '* F' - ] ) ); + runTest( { + input: [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ], + expected: [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'non-collapsed selection starting in first block of a list item', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - '* [', - '* ]', - ' ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' ' - ] ) ); + runTest( { + input: [ + '* [', + '* ]', + ' ' + ], + expected: [ + '* []', + ' ' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + expected: [ + '* []text{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + expected: [ + '* []xt{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b' + ], + expected: [ + '* []', + '* b {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* []{id:000}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* []', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all following items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - ' text', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:004}' - ] ) ); + runTest( { + input: [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all following items till the end of selection and merge last list itemxx', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' ]c', - ' * d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* c', - ' * d {id:003}', - ' e' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' ]c', + ' * d', + ' e' + ], + expected: [ + '* []', + '* c', + ' * d {id:003}', + ' e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete items till the end of selection and merge middle block with following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' c]d', - ' * e', - ' f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d{id:001}', - ' * e{id:003}', - ' f' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ], + expected: [ + '* []d{id:001}', + ' * e{id:003}', + ' f' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete items till the end of selection and merge following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' cd]', - ' * e', - ' f', - ' s' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' * e {id:003}', - ' f', - '* s {id:001}' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' cd]', + ' * e', + ' f', + ' s' + ], + expected: [ + '* []', + ' * e {id:003}', + ' f', + '* s {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'first position in non-empty block', () => { it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}', - ' text' - ] ) ); + runTest( { + input: [ + '* [text', + '* ano]ther', + ' text' + ], + expected: [ + '* []ther{id:001}', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); // Not related to merge command it( 'should merge two list items with selection in the middle', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); + runTest( { + input: [ + '* te[xt', + '* ano]ther' + ], + expected: [ + '* te[]ther' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + expected: [ + '* []text{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + expected: [ + '* []xt{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}', - ' * c {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b', + ' * c' + ], + expected: [ + '* []', + '* b {id:002}', + ' * c {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* []{id:000}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* []', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]', - ' c', - ' * d', - ' e', - ' f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' c', - ' * d {id:004}', - ' e', - '* f {id:001}', - ' g' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f', + ' g' + ], + expected: [ + '* []', + ' c', + ' * d {id:004}', + ' e', + '* f {id:001}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); @@ -1723,561 +2069,709 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'selection outside list', () => { describe( 'collapsed selection', () => { it( 'no list editing commands should be executed outside list (empty paragraph)', () => { - setModelData( model, - '[]' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - '[]' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '[]' + ], + expected: [ + '[]' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed outside list (selection at the beginning of text)', () => { - setModelData( model, - '[]text' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - '[]text' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '[]text' + ], + expected: [ + '[]text' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed outside list (selection at the end of text)', () => { - setModelData( model, - 'text[]' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - 'tex[]' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + 'text[]' + ], + expected: [ + 'tex[]' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed outside list (selection in the middle of text)', () => { - setModelData( model, - 'te[]xt' - ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( - 't[]xt' - ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + 'te[]xt' + ], + expected: [ + 't[]xt' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed next to a list', () => { - setModelData( model, modelList( [ - '1[]', - '* 2' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]', - '* 2' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '1[]', + '* 2' + ], + expected: [ + '[]', + '* 2' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed when merging two lists', () => { - setModelData( model, modelList( [ - '* 1', - '[]2', - '* 3' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* 1[]2', - '* 3 {id:002}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '* 1', + '[]2', + '* 3' + ], + expected: [ + '* 1[]2', + '* 3 {id:002}' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed when merging two lists - one nested', () => { - setModelData( model, modelList( [ - '* 1', - '[]2', - '* 3', - ' * 4' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* 1[]2', - '* 3 {id:002}', - ' * 4 {id:003}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '* 1', + '[]2', + '* 3', + ' * 4' + ], + expected: [ + '* 1[]2', + '* 3 {id:002}', + ' * 4 {id:003}' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'empty list should be deleted', () => { - setModelData( model, modelList( [ - '* ', - '[]2', - '* 3' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]2', - '* 3 {id:002}' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '* ', + '[]2', + '* 3' + ], + expected: [ + '[]2', + '* 3 {id:002}' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); } ); describe( 'non-collapsed selection', () => { describe( 'outside list', () => { it( 'no list editing commands should be executed', () => { - setModelData( model, modelList( [ - 't[ex]t' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 't[]t' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + 't[ex]t' + ], + expected: [ + 't[]t' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed when outside list when next to a list', () => { - setModelData( model, modelList( [ - 't[ex]t', - '* 1' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 't[]t', - '* 1' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + 't[ex]t', + '* 1' + ], + expected: [ + 't[]t', + '* 1' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); } ); describe( 'only start in a list', () => { it( 'no list editing commands should be executed when doing delete', () => { - setModelData( model, modelList( [ - '* te[xt', - 'aa]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '* te[xt', + 'aa]' + ], + expected: [ + '* te[]' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'no list editing commands should be executed when doing delete (multi-block list)', () => { - setModelData( model, modelList( [ - '* te[xt1', - ' text2', - ' * text3', - 'text4]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]' - ] ) ); - - expect( changedBlocks ).to.be.empty; - - sinon.assert.notCalled( outdentCommandExecuteSpy ); - sinon.assert.notCalled( splitAfterCommandExecuteSpy ); + runTest( { + input: [ + '* te[xt1', + ' text2', + ' * text3', + 'text4]' + ], + expected: [ + '* te[]' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); it( 'should delete everything till end of selection and merge remaining text', () => { - setModelData( model, modelList( [ - '* text1', - ' tex[t2', - ' * text3', - 'tex]t4' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text1', - ' tex[]t4' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* text1', + ' tex[t2', + ' * text3', + 'tex]t4' + ], + expected: [ + '* text1', + ' tex[]t4' + ], + eventStopped: { + preventDefault: 1, + stop: undefined + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); } ); } ); describe( 'only end in a list', () => { it( 'should delete everything till end of selection', () => { - setModelData( model, modelList( [ - '[', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt {id:001}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '[', + '* te]xt' + ], + expected: [ + '* []xt {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete everything till the end of selection and adjust remaining block to item list', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + 'a[', + '* b]b', + ' c' + ], + expected: [ + 'a[]b', + '* c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete everything till the end of selection and adjust remaining item list indentation', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c {id:002}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + 'a[', + '* b]b', + ' * c' + ], + expected: [ + 'a[]b', + '* c {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete selection and adjust remaining item list indentation (multi-block)', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' * c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c {id:002}', - ' d' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + 'a[', + '* b]b', + ' * c', + ' d' + ], + expected: [ + 'a[]b', + '* c {id:002}', + ' d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); // TODO: skipped because below TODO it.skip( 'should remove selection and adjust remaining list', () => { - setModelData( model, modelList( [ - 'a[', - '* b]b', - ' * c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]b', - '* c', - ' d' // TODO: No way currently to adjust this block id <- - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + 'a[', + '* b]b', + ' * c', + ' d' + ], + expected: [ + 'a[]b', + '* c', + ' d' // TODO: No way currently to adjust this block id <- + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove selection and adjust remaining list (multi-block)', () => { - setModelData( model, modelList( [ - 'a[', - '* b', - ' * c', - ' d]d', - ' * e', - ' f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a[]d', - '* e {id:004}', - ' f' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + 'a[', + '* b', + ' * c', + ' d]d', + ' * e', + ' f' + ], + expected: [ + 'a[]d', + '* e {id:004}', + ' f' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'spanning multiple lists', () => { it( 'should merge lists into one with one list item', () => { - setModelData( model, modelList( [ - '* a[a', - 'b', - '* c]c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]c' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a[a', + 'b', + '* c]c' + ], + expected: [ + '* a[]c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge lists into one with two blocks', () => { - setModelData( model, modelList( [ - '* a', - ' b[b', - 'c', - '* d]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]d' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a', + ' b[b', + 'c', + '* d]d' + ], + expected: [ + '* a', + ' b[]d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two lists into one with two list items', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d]', - '* e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - '* e {id:003}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a[', + 'c', + '* d]', + '* e' + ], + expected: [ + '* a[]', + '* e {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two lists into one with two list items (multiple blocks)', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d]', - ' e', - '* f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - ' e', - '* f {id:004}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a[', + 'c', + '* d]', + ' e', + '* f' + ], + expected: [ + '* a[]', + ' e', + '* f {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two lists into one with two list items and adjust indentation', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d', - ' * e]e', - ' * f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]e', - ' * f {id:004}', - ' g' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ], + expected: [ + '* a[]e', + ' * f {id:004}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two lists into one with deeper indendation', () => { - setModelData( model, modelList( [ - '* a', - ' * b[', - 'c', - '* d', - ' * e', - ' * f]f', - ' * g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]f', - ' * g {id:006}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a', + ' * b[', + 'c', + '* d', + ' * e', + ' * f]f', + ' * g' + ], + expected: [ + '* a', + ' * b[]f', + ' * g {id:006}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two lists into one with deeper indentation (multiple blocks)', () => { - setModelData( model, modelList( [ - '* a', - ' * b[', - 'c', - '* d', - ' * e]e', - ' * f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]e', - ' * f {id:005}', - ' g' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a', + ' * b[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ], + expected: [ + '* a', + ' * b[]e', + ' * f {id:005}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two lists into one and keep items after selection', () => { - setModelData( model, modelList( [ - '* a[', - 'c', - '* d', - ' * e]e', - '* f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]e', - '* f {id:004}', - ' g' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a[', + 'c', + '* d', + ' * e]e', + '* f', + ' g' + ], + expected: [ + '* a[]e', + '* f {id:004}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge lists of different types to a single list and keep item lists types', () => { - setModelData( model, modelList( [ - '* a', - '* b[b', - 'c', - '# d]d', - '# d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '* b[]d', - '# d {id:004}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a', + '* b[b', + 'c', + '# d]d', + '# d' + ], + expected: [ + '* a', + '* b[]d', + '# d {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge lists of mixed types to a single list and keep item lists types', () => { - setModelData( model, modelList( [ - '* a', - '# b[b', - 'c', - '# d]d', - ' * f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - '# b[]d', - ' * f {id:004}' - ] ) ); - - expect( changedBlocks ).to.be.empty; + runTest( { + input: [ + '* a', + '# b[b', + 'c', + '# d]d', + ' * f' + ], + expected: [ + '* a', + '# b[]d', + ' * f {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); @@ -2298,269 +2792,333 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'single block list item', () => { describe( 'collapsed selection at the end of a list item', () => { describe( 'item after is empty', () => { - it.skip( 'should remove list when in empty only element of a list', () => { - setModelData( model, modelList( [ - '* []' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '[]' - ] ) ); + it( 'should remove list when in empty only element of a list', () => { + runTest( { + input: [ + '* []' + ], + expected: [ + '[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove next empty list item', () => { - setModelData( model, modelList( [ - '* b[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b[]' - ] ) ); - - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* b[]', + '* ' + ], + expected: [ + '* b[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove next empty list item when current is empty', () => { - setModelData( model, modelList( [ - '* []', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + '* ' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove current list item if empty and replace with indented', () => { - setModelData( model, modelList( [ - '* []', - ' * a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - sinon.assert.calledOnce( mergeForwardCommandExecuteSpy ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}' - ] ) ); - - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + ' * a' + ], + expected: [ + '* []a {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove next empty indented item list', () => { - setModelData( model, modelList( [ - '* []', - ' * ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + ' * ' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should replace current empty list item with next list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * []', + '* a' + ], + expected: [ + '* ', + ' * []a{id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove next empty list item when current is also empty', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * []', + '* ' + ], + expected: [ + '* ', + ' * []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'next list item is not empty', () => { it( 'should merge text from next list item with current list item text', () => { - setModelData( model, modelList( [ - '* a[]', - '* b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + '* b' + ], + expected: [ + '* a[]b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete next empty item list', () => { - setModelData( model, modelList( [ - '* a[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + '* ' + ], + expected: [ + '* a[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge text of indented list item with current list item', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + ' * b' + ], + expected: [ + '* a[]b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should remove indented empty list item', () => { - setModelData( model, modelList( [ - '* a[]', - ' * ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + ' * ' + ], + expected: [ + '* a[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge text of lower indent list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b[]', - '* c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]c' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b[]', + '* c' + ], + expected: [ + '* a', + ' * b[]c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete next empty list item with lower ident', () => { - setModelData( model, modelList( [ - '* a', - ' * b[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b[]', + '* ' + ], + expected: [ + '* a', + ' * b[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge following item list of first block and adjust it\'s children', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - ' * c {id:002}', - ' * d {id:003}', - ' e', - ' * f {id:005}', - ' * g {id:006}', - ' h' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + ' * b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + expected: [ + '* a[]b', + ' * c {id:002}', + ' * d {id:003}', + ' e', + ' * f {id:005}', + ' * g {id:006}', + ' h' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge following first block of an item list and make second block a first one', () => { - setModelData( model, modelList( [ - '* a[]', - ' * b', - ' b2', - ' * c', - ' * d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - ' b2', - ' * c {id:003}', - ' * d {id:004}', - ' e' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + ' * b', + ' b2', + ' * c', + ' * d', + ' e' + ], + expected: [ + '* a[]b', + ' b2', + ' * c {id:003}', + ' * d {id:004}', + ' e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); @@ -2568,257 +3126,375 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'non-collapsed selection starting in first block of a list item', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - 'a', - '* [', - '* ]' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - 'a', - '* []' - ] ) ); + runTest( { + input: [ + 'a', + '* [', + '* ]' + ], + expected: [ + 'a', + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + expected: [ + '* []text{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + expected: [ + '* []xt{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b' + ], + expected: [ + '* []', + '* b {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* []{id:000}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* []', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'first position in non-empty block', () => { it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}' - ] ) ); + runTest( { + input: [ + '* [text', + '* ano]ther' + ], + expected: [ + '* []ther{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge two list items if selection starts in the middle of text', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); + runTest( { + input: [ + '* te[xt', + '* ano]ther' + ], + expected: [ + '* te[]ther' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* text[', - '* ]another' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]another' - ] ) ); + runTest( { + input: [ + '* text[', + '* ]another' + ], + expected: [ + '* text[]another' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* text[', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]ther' - ] ) ); + runTest( { + input: [ + '* text[', + '* ano]ther' + ], + expected: [ + '* text[]ther' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* b {id:002}', - ' * c {id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * ]b', + ' * c' + ], + expected: [ + '* text[]', + '* b {id:002}', + ' * c {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]c', - ' * d {id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* text[]c', + ' * d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[] {id:000}', - ' * d {id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* text[] {id:000}', + ' * d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - // output is okay, fix expect - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* text[]', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* text[]e' - ] ) ); + runTest( { + input: [ + '* text[', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* text[]e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); @@ -2828,740 +3504,995 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'collapsed selection at the end of a list item', () => { describe( 'item after is empty', () => { it( 'should remove empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' b[]', - '* ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' b[]', + '* ' + ], + expected: [ + '* a', + ' b[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it.skip( 'should merge following complex list item with current one', () => { - setModelData( model, modelList( [ - '* ', - ' []', - '* b', - ' c', - ' * d {id:d}', - ' e', - ' * f {id:f}', - ' * g {id:g}', - ' h', - ' * i {id:i}', - ' * j {id:j}', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' []b', - ' c', - ' * d {id:d}', - ' e', - ' * f {id:f}', - ' * g {id:g}', - ' h', - ' * i {id:i}', - ' * j {id:j}', - ' k', - ' l' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' []', + '* b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ], + expected: [ + '* ', + ' []b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and remove block of same list item', () => { - setModelData( model, modelList( [ - '* []', - ' a' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + ' a' + ], + expected: [ + '* []a' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with currently selected list item', () => { - setModelData( model, modelList( [ - '* []', - ' * a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}', - ' b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + ' * a', + ' b' + ], + expected: [ + '* []a{id:001}', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setModelData( model, modelList( [ - '* []', - ' * a', - ' b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []a {id:001}', - ' b', - ' * c {id:003}' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + ' * a', + ' b', + ' * c' + ], + expected: [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with first block empty', () => { - setModelData( model, modelList( [ - '* []', - ' * ', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* []', + ' * ', + ' text' + ], + expected: [ + '* []', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge next outdented list item', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* a', - ' b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a {id:002}', - ' b' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * []', + '* a', + ' b' + ], + expected: [ + '* ', + ' * []a {id:002}', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge next outdented list item with first block empty', () => { - setModelData( model, modelList( [ - '* ', - ' * []', - '* ', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []', - ' text' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* ', + ' * []', + '* ', + ' text' + ], + expected: [ + '* ', + ' * []', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'list item after is not empty', () => { it( 'should merge with previous list item and keep blocks intact', () => { - setModelData( model, modelList( [ - '* a[]', - '* b', - ' c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - ' c' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a[]', + '* b', + ' c' + ], + expected: [ + '* a[]b', + ' c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge all following outdented blocks', () => { - setModelData( model, modelList( [ - '* b', - ' * c', - ' c2[]', - ' d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' c2[]d', - ' e' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* b', + ' * c', + ' c2[]', + ' d', + ' e' + ], + expected: [ + '* b', + ' * c', + ' c2[]d', + ' e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge complex list item', () => { - setModelData( model, modelList( [ - '* a', - ' a2[]', - '* b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' a2[]b', - ' c', - ' * d {id:004}', - ' e', - ' * f {id:006}', - ' * g {id:007}', - ' h', - ' * i {id:009}', - ' * j {id:010}', - ' k', - ' l' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' a2[]', + '* b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + expected: [ + '* a', + ' a2[]b', + ' c', + ' * d {id:004}', + ' e', + ' * f {id:006}', + ' * g {id:007}', + ' h', + ' * i {id:009}', + ' * j {id:010}', + ' k', + ' l' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with next multi-block list item', () => { - setModelData( model, modelList( [ - '* a', - ' a2[]', - '* b', - ' b2' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' a2[]b', - ' b2' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' a2[]', + '* b', + ' b2' + ], + expected: [ + '* a', + ' a2[]b', + ' b2' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge outdented multi-block list item', () => { - setModelData( model, modelList( [ - '* a', - ' a2[]', - ' * b', - ' b2' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' a2[]b', - ' b2' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' a2[]', + ' * b', + ' b2' + ], + expected: [ + '* a', + ' a2[]b', + ' b2' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge an outdented list item in an outdented list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - ' c[]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' c[]d' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b', + ' c[]', + ' * d' + ], + expected: [ + '* a', + ' * b', + ' c[]d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b', - ' c[]', - ' * ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' c[]' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b', + ' c[]', + ' * ' + ], + expected: [ + '* a', + ' * b', + ' c[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with next outdented list item', () => { - setModelData( model, modelList( [ - '* a', - ' * b[]', - '* c', - ' d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b[]c', - ' d' - ] ) ); - - sinon.assert.calledOnce( domEventData.domEvent.preventDefault ); - expect( eventInfo.stop.called ).to.be.true; + runTest( { + input: [ + '* a', + ' * b[]', + '* c', + ' d' + ], + expected: [ + '* a', + ' * b[]c', + ' d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); describe( 'collapsed selection in the middle of the list item', () => { it( 'should merge next indented list item', () => { - setModelData( model, modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' X[]', - ' # Z', - ' V', - '* E', - '* F' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* A', - ' * B', - ' # C', - ' # D', - ' X[]Z', - ' V', - '* E {id:007}', - '* F {id:008}' - ] ) ); + runTest( { + input: [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]', + ' # Z', + ' V', + '* E', + '* F' + ], + expected: [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]Z', + ' V', + '* E {id:007}', + '* F {id:008}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'non-collapsed selection starting in first block of a list item', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { - setModelData( model, modelList( [ - '* [', - '* ]', - ' ' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' ' - ] ) ); + runTest( { + input: [ + '* [', + '* ]', + ' ' + ], + expected: [ + '* []', + ' ' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text {id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + expected: [ + '* []text {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt {id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + expected: [ + '* []xt {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b' + ], + expected: [ + '* []', + '* b {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c {id:002}', - ' * d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* []c {id:002}', + ' * d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* [] {id:000}', - ' * d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* [] {id:000}', + ' * d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* []', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all following items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - ' text', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e {id:004}' - ] ) ); + runTest( { + input: [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all following items till the end of selection and merge last list itemxx', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' ]c', - ' * d', - ' e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* c', - ' * d {id:003}', - ' e' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' ]c', + ' * d', + ' e' + ], + expected: [ + '* []', + '* c', + ' * d {id:003}', + ' e' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete items till the end of selection and merge middle block with following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' c]d', - ' * e', - ' f' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []d {id:001}', - ' * e {id:003}', - ' f' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ], + expected: [ + '* []d {id:001}', + ' * e {id:003}', + ' f' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete items till the end of selection and merge following blocks', () => { - setModelData( model, modelList( [ - '* [', - ' * b', - ' cd]', - ' * e', - ' f', - ' s' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' * e {id:003}', - ' f', - '* s {id:001}' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' cd]', + ' * e', + ' f', + ' s' + ], + expected: [ + '* []', + ' * e {id:003}', + ' f', + '* s {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'first position in non-empty block', () => { it( 'should merge two list items', () => { - setModelData( model, modelList( [ - '* [text', - '* ano]ther', - ' text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []ther {id:001}', - ' text' - ] ) ); + runTest( { + input: [ + '* [text', + '* ano]ther', + ' text' + ], + expected: [ + '* []ther {id:001}', + ' text' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); // Not related to merge command it( 'should merge two list items with selection in the middle', () => { - setModelData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); + runTest( { + input: [ + '* te[xt', + '* ano]ther' + ], + expected: [ + '* te[]ther' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setModelData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []text {id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + expected: [ + '* []text {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setModelData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + expected: [ + '* []xt{id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * ]b', - ' * c' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b {id:002}', - ' * c {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b', + ' * c' + ], + expected: [ + '* []', + '* b {id:002}', + ' * c {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* [] {id:000}', - ' * d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + expected: [ + '* [] {id:000}', + ' * d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d {id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + expected: [ + '* []', + '* d {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + expected: [ + '* []e{id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { - setModelData( model, modelList( [ - '* [', - '* a', - ' * b]', - ' c', - ' * d', - ' e', - ' f', - ' g' - ] ) ); - - view.document.fire( eventInfo, domEventData ); - - expect( getModelData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' c', - ' * d {id:004}', - ' e', - '* f {id:001}', - ' g' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f', + ' g' + ], + expected: [ + '* []', + ' c', + ' * d {id:004}', + ' e', + '* f {id:001}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); } ); } ); } ); } ); } ); + + function runTest( { input, expected, eventStopped, executedCommands = {} } ) { + // function runTest( { input, expected, eventStopped, executedCommands = {}, changedBlocks = [] } ) { + setModelData( model, modelList( input ) ); + + view.document.fire( eventInfo, domEventData ); + + expect( getModelData( model ) ).to.equalMarkup( modelList( expected ) ); + + if ( typeof eventStopped === 'object' ) { + expect( domEventData.domEvent.preventDefault.callCount ).to.equal( eventStopped.preventDefault, 'preventDefault() call' ); + expect( eventInfo.stop.called ).to.equal( eventStopped.stop, 'eventInfo.stop() call' ); + } else { + if ( eventStopped ) { + expect( domEventData.domEvent.preventDefault.callCount ).to.equal( 1, 'preventDefault() call' ); + expect( eventInfo.stop.called ).to.equal( true, 'eventInfo.stop() call' ); + } else { + expect( domEventData.domEvent.preventDefault.callCount ).to.equal( 0, 'preventDefault() call' ); + expect( eventInfo.stop.called ).to.equal( undefined, 'eventInfo.stop() call' ); + } + } + + for ( const name in executedCommands ) { + expect( commandSpies[ name ].callCount ).to.equal( executedCommands[ name ], `${ name } command call count` ); + } + + // TODO: Enable it once all commands return this info. + // expect( blocksChangedByCommands.length ).to.equal( changedBlocks.length, 'changed blocks length' ); + // expect( blocksChangedByCommands.map( block => block.index ) ).to.deep.equal( changedBlocks ), 'changed blocks\' indexes' ); + } } ); From 7b908fa6bd0c4e9811923a3b10743b6c9eb7293e Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 25 Jan 2022 16:06:19 +0100 Subject: [PATCH 20/44] Skip DocumentListMergeCommand tests for now. They need refactoring anyway. --- .../tests/documentlist/documentlistmergecommand.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js index 18b6bb0eb0c..85917025c2f 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js @@ -12,7 +12,7 @@ import Model from '@ckeditor/ckeditor5-engine/src/model/model'; import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; import { setData, getData } from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; -describe( 'DocumentListMergeCommand', () => { +describe.skip( 'DocumentListMergeCommand', () => { let editor, model, doc, command; testUtils.createSinonSandbox(); From dd4d81af4d55a46b818f1e67e0dbb4f5aa173bf1 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 26 Jan 2022 15:00:05 +0100 Subject: [PATCH 21/44] Delete and backspace actions in DocumentListEditing should announce the list of changed blocks. --- .../documentlist/documentlistmergecommand.js | 16 +- .../src/documentlist/utils/model.js | 4 +- .../tests/documentlist/integrations/delete.js | 382 +++++++++--------- 3 files changed, 204 insertions(+), 198 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index bfc4cbcf7dd..8136b13d274 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -11,6 +11,7 @@ import { Command } from 'ckeditor5/src/core'; import { getNestedListBlocks, indentBlocks, + sortBlocks, isFirstBlockOfListItem, mergeListItemBefore } from './utils/model'; @@ -58,6 +59,7 @@ export default class DocumentListMergeCommand extends Command { execute( { deleteContent = false } = {} ) { const model = this.editor.model; const selection = model.document.selection; + const changedBlocks = []; model.change( writer => { let firstElement, lastElement; @@ -99,12 +101,12 @@ export default class DocumentListMergeCommand extends Command { if ( firstIndent != lastIndent ) { const nestedLastElementBlocks = getNestedListBlocks( lastElement ); - indentBlocks( [ lastElement, ...nestedLastElementBlocks ], writer, { + changedBlocks.push( ...indentBlocks( [ lastElement, ...nestedLastElementBlocks ], writer, { indentBy: firstIndent - lastIndent, // If outdenting, the entire sub-tree that follows must be included. expand: firstIndent < lastIndent - } ); + } ) ); } if ( deleteContent ) { @@ -128,14 +130,16 @@ export default class DocumentListMergeCommand extends Command { // Check if the element after it was in the same list item and adjust it if needed. const nextSibling = lastElementAfterDelete.nextSibling; + changedBlocks.push( lastElementAfterDelete ); + if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { - mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ); + changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); } } else { - mergeListItemBefore( lastElement, firstElement, writer ); + changedBlocks.push( ...mergeListItemBefore( lastElement, firstElement, writer ) ); } - // TODO this._fireAfterExecute() + this._fireAfterExecute( changedBlocks ); } ); } @@ -155,7 +159,7 @@ export default class DocumentListMergeCommand extends Command { * @protected * @event afterExecute */ - this.fire( 'afterExecute', changedBlocks ); + this.fire( 'afterExecute', sortBlocks( new Set( changedBlocks ) ) ); } /** diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index fa95acb04fb..dea4ef3cd59 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -477,7 +477,9 @@ export function outdentFollowingItems( lastBlock, writer ) { * @returns {Array.} The sorted array of blocks. */ export function sortBlocks( blocks ) { - return Array.from( blocks ).sort( ( a, b ) => a.index - b.index ); + return Array.from( blocks ) + .filter( block => block.root.rootName !== '$graveyard' ) + .sort( ( a, b ) => a.index - b.index ); } // Merges a given block to the given parent block if parent is a list item and there is no more blocks in the same item. diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 93fe9044c7e..9c0ebe210ef 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -46,7 +46,6 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { model = editor.model; view = editor.editing.view; - // modelRoot = model.document.getRoot(); model.schema.extend( 'paragraph', { allowAttributes: 'foo' @@ -156,7 +155,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 0, 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -176,7 +175,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -216,7 +215,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -238,7 +237,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1, 2 ] + changedBlocks: [ 1 ] } ); } ); @@ -260,7 +259,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 2 ] + changedBlocks: [ 1 ] } ); } ); } ); @@ -449,7 +448,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -470,7 +469,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -490,7 +489,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -510,7 +509,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -532,7 +531,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 2 ] + changedBlocks: [ 1 ] } ); } ); @@ -554,7 +553,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 2 ] + changedBlocks: [ 1 ] } ); } ); } ); @@ -745,7 +744,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 2 ] + changedBlocks: [ 1 ] } ); } ); @@ -765,7 +764,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -785,7 +784,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -807,7 +806,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -830,7 +829,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 0, 1, 2 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -853,7 +852,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 0, 1, 2, 3 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -876,7 +875,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 0, 1, 2 ] + changedBlocks: [ 0 ] } ); } ); @@ -898,7 +897,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 0, 1, 2 ] + changedBlocks: [ 0 ] } ); } ); } ); @@ -920,7 +919,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -940,7 +939,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -960,7 +959,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -980,7 +979,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1004,7 +1003,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -1027,7 +1026,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1050,7 +1049,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1073,7 +1072,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1095,7 +1094,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); } ); @@ -1123,7 +1122,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 0 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1140,7 +1139,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' h', ' * i', ' * j', - ' k', + ' k', ' l' ], expected: [ @@ -1153,7 +1152,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' h', ' * i {id:008}', ' * j {id:009}', - ' k', + ' k', ' l' ], eventStopped: true, @@ -1163,7 +1162,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] + changedBlocks: [ 0, 1, 10 ] } ); } ); @@ -1185,7 +1184,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 0 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1207,7 +1206,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 0, 1, 2 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1231,7 +1230,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 0, 1, 2, 3 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -1253,7 +1252,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 0, 1, 2 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1277,7 +1276,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 2, 3 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -1301,7 +1300,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); } ); @@ -1326,7 +1325,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -1351,7 +1350,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 2 ] } ); } ); @@ -1392,7 +1391,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2, 11 ] } ); } ); @@ -1415,7 +1414,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -1438,7 +1437,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -1463,7 +1462,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2, 3 ] } ); } ); @@ -1486,7 +1485,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -1511,7 +1510,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 2, 3 ] } ); } ); } ); @@ -1549,7 +1548,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 1, mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [ 4, 5 ] } ); } ); } ); @@ -1574,7 +1573,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1594,7 +1593,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1614,7 +1613,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1636,7 +1635,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1659,7 +1658,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1682,7 +1681,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1705,7 +1704,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1727,7 +1726,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1750,11 +1749,11 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); - it( 'should delete all following items till the end of selection and merge last list itemxx', () => { + it( 'should delete all following items till the end of selection and merge last list itemx', () => { runTest( { input: [ '* [', @@ -1776,7 +1775,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3 ] } ); } ); @@ -1801,7 +1800,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -1828,7 +1827,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3 ] } ); } ); } ); @@ -1852,7 +1851,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1873,7 +1872,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1893,7 +1892,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1913,7 +1912,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -1937,7 +1936,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -1960,7 +1959,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -1983,7 +1982,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -2006,7 +2005,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2028,7 +2027,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2059,7 +2058,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3 ] } ); } ); } ); @@ -2077,8 +2076,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '[]' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2099,8 +2098,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '[]text' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2121,8 +2120,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { 'tex[]' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2143,8 +2142,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { 't[]xt' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2167,8 +2166,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* 2' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2192,8 +2191,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* 3 {id:002}' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2219,8 +2218,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' * 4 {id:003}' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2244,8 +2243,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* 3 {id:002}' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2269,8 +2268,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { 't[]t' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2293,8 +2292,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* 1' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2318,8 +2317,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* te[]' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2343,8 +2342,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* te[]' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2369,8 +2368,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' tex[]t4' ], eventStopped: { - preventDefault: 1, - stop: undefined + preventDefault: true, + stop: false }, executedCommands: { outdent: 0, @@ -2400,7 +2399,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2422,7 +2421,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -2444,7 +2443,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + // Note: Technically speaking "c" should also be included but wasn't; was fixed by model post-fixer. + changedBlocks: [ 0 ] } ); } ); @@ -2468,12 +2468,12 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + // Note: Technically speaking "c" and "d" should also be included but weren't; fixed by model post-fixer. + changedBlocks: [ 0 ] } ); } ); - // TODO: skipped because below TODO - it.skip( 'should remove selection and adjust remaining list', () => { + it( 'should remove selection and adjust remaining list', () => { runTest( { input: [ 'a[', @@ -2483,8 +2483,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ], expected: [ 'a[]b', - '* c', - ' d' // TODO: No way currently to adjust this block id <- + '* c {id:002}', + '* d {id:001}' ], eventStopped: true, executedCommands: { @@ -2493,7 +2493,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + // Note: Technically speaking "c" and "d" should also be included but weren't; fixed by model post-fixer. + changedBlocks: [ 0 ] } ); } ); @@ -2519,7 +2520,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); } ); @@ -2542,7 +2543,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2588,7 +2589,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2613,7 +2614,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -2639,7 +2640,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -2666,7 +2667,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -2720,7 +2721,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2792,6 +2793,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'single block list item', () => { describe( 'collapsed selection at the end of a list item', () => { describe( 'item after is empty', () => { + // TODO: This should be handled by #isEnabled. it( 'should remove list when in empty only element of a list', () => { runTest( { input: [ @@ -2827,7 +2829,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2847,7 +2849,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2867,7 +2869,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2887,7 +2889,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2953,7 +2955,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2973,7 +2975,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -2993,7 +2995,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3013,7 +3015,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3089,7 +3091,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3, 4, 5, 6 ] } ); } ); @@ -3117,7 +3119,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3, 4 ] } ); } ); } ); @@ -3163,7 +3165,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3183,7 +3185,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3205,7 +3207,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3228,7 +3230,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3251,7 +3253,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3274,7 +3276,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3296,7 +3298,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); } ); @@ -3318,7 +3320,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3338,7 +3340,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3358,7 +3360,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3378,7 +3380,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3402,7 +3404,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -3425,7 +3427,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3448,7 +3450,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3471,7 +3473,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3493,7 +3495,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); } ); @@ -3583,7 +3585,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -3605,7 +3607,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3629,7 +3631,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -3651,7 +3653,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3675,7 +3677,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -3699,7 +3701,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); } ); @@ -3723,7 +3725,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3749,7 +3751,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 2, 3 ] } ); } ); @@ -3791,7 +3793,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2, 11 ] } ); } ); @@ -3815,7 +3817,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -3839,7 +3841,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); @@ -3863,7 +3865,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 2 ] } ); } ); @@ -3887,7 +3889,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 2 ] } ); } ); @@ -3911,7 +3913,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2 ] } ); } ); } ); @@ -3948,7 +3950,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 4 ] } ); } ); } ); @@ -3973,7 +3975,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -3993,7 +3995,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4013,7 +4015,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4035,7 +4037,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -4058,7 +4060,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -4081,7 +4083,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -4104,7 +4106,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4126,7 +4128,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4149,11 +4151,11 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); - it( 'should delete all following items till the end of selection and merge last list itemxx', () => { + it( 'should delete all following items till the end of selection and merge last list itemx', () => { runTest( { input: [ '* [', @@ -4175,7 +4177,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3 ] } ); } ); @@ -4200,7 +4202,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -4227,7 +4229,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3 ] } ); } ); } ); @@ -4251,7 +4253,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -4272,7 +4274,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4292,7 +4294,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4312,7 +4314,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4336,7 +4338,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2 ] } ); } ); @@ -4359,7 +4361,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -4382,7 +4384,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1 ] } ); } ); @@ -4405,7 +4407,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4427,7 +4429,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0 ] } ); } ); @@ -4458,7 +4460,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 0, 1, 2, 3 ] } ); } ); } ); @@ -4466,8 +4468,13 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - function runTest( { input, expected, eventStopped, executedCommands = {} } ) { - // function runTest( { input, expected, eventStopped, executedCommands = {}, changedBlocks = [] } ) { + // @param {Iterable.} input + // @param {Iterable.} expected + // @param {Boolean|Object.} eventStopped Boolean when preventDefault() and stop() were called/not called together. + // Object, when mixed behavior was expected. + // @param {Object.} executedCommands Numbers of command executions. + // @param {Array.} changedBlocks Indexes of changed blocks. + function runTest( { input, expected, eventStopped, executedCommands = {}, changedBlocks = [] } ) { setModelData( model, modelList( input ) ); view.document.fire( eventInfo, domEventData ); @@ -4475,24 +4482,17 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { expect( getModelData( model ) ).to.equalMarkup( modelList( expected ) ); if ( typeof eventStopped === 'object' ) { - expect( domEventData.domEvent.preventDefault.callCount ).to.equal( eventStopped.preventDefault, 'preventDefault() call' ); - expect( eventInfo.stop.called ).to.equal( eventStopped.stop, 'eventInfo.stop() call' ); + expect( domEventData.domEvent.preventDefault.called ).to.equal( eventStopped.preventDefault, 'preventDefault() call' ); + expect( !!eventInfo.stop.called ).to.equal( eventStopped.stop, 'eventInfo.stop() call' ); } else { - if ( eventStopped ) { - expect( domEventData.domEvent.preventDefault.callCount ).to.equal( 1, 'preventDefault() call' ); - expect( eventInfo.stop.called ).to.equal( true, 'eventInfo.stop() call' ); - } else { - expect( domEventData.domEvent.preventDefault.callCount ).to.equal( 0, 'preventDefault() call' ); - expect( eventInfo.stop.called ).to.equal( undefined, 'eventInfo.stop() call' ); - } + expect( domEventData.domEvent.preventDefault.callCount ).to.equal( eventStopped ? 1 : 0, 'preventDefault() call' ); + expect( eventInfo.stop.called ).to.equal( eventStopped ? true : undefined, 'eventInfo.stop() call' ); } for ( const name in executedCommands ) { expect( commandSpies[ name ].callCount ).to.equal( executedCommands[ name ], `${ name } command call count` ); } - // TODO: Enable it once all commands return this info. - // expect( blocksChangedByCommands.length ).to.equal( changedBlocks.length, 'changed blocks length' ); - // expect( blocksChangedByCommands.map( block => block.index ) ).to.deep.equal( changedBlocks ), 'changed blocks\' indexes' ); + expect( blocksChangedByCommands.map( block => block.index ) ).to.deep.equal( changedBlocks, 'changed blocks\' indexes' ); } } ); From a24effc099e74bc921c0c99284a5ab74a19aa41e Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Thu, 27 Jan 2022 11:42:23 +0100 Subject: [PATCH 22/44] WIP. --- .../src/documentlist/documentlistediting.js | 12 +- .../documentlist/documentlistmergecommand.js | 151 ++++++++++++------ .../tests/documentlist/integrations/delete.js | 2 +- 3 files changed, 105 insertions(+), 60 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 2257d7b822f..51444507c49 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -138,13 +138,9 @@ export default class DocumentListEditing extends Plugin { return; } - editor.execute( 'mergeListItemBackward', { - deleteContent: false - } ); + editor.execute( 'mergeListItemBackward' ); } else { - editor.execute( 'mergeListItemBackward', { - deleteContent: previousSibling.isEmpty || isInsideSingleListItem - } ); + editor.execute( 'mergeListItemBackward' ); } } @@ -172,9 +168,7 @@ export default class DocumentListEditing extends Plugin { // return; // } - editor.execute( 'mergeListItemForward', { - deleteContent: true - } ); + editor.execute( 'mergeListItemForward' ); data.preventDefault(); evt.stop(); diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 8136b13d274..8392bbfda4d 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -13,7 +13,9 @@ import { indentBlocks, sortBlocks, isFirstBlockOfListItem, - mergeListItemBefore + mergeListItemBefore, + isSingleListItem, + isListItemBlock } from './utils/model'; import ListWalker from './utils/listwalker'; @@ -47,7 +49,7 @@ export default class DocumentListMergeCommand extends Command { * @inheritDoc */ refresh() { - this.isEnabled = true; // this._checkEnabled(); + this.isEnabled = this._checkEnabled(); } /** @@ -56,43 +58,14 @@ export default class DocumentListMergeCommand extends Command { * @fires execute * @fires afterExecute */ - execute( { deleteContent = false } = {} ) { + execute() { const model = this.editor.model; const selection = model.document.selection; const changedBlocks = []; model.change( writer => { - let firstElement, lastElement; - - if ( selection.isCollapsed ) { - const positionParent = selection.getFirstPosition().parent; - const isFirstBlock = isFirstBlockOfListItem( positionParent ); - - if ( this._direction == 'backward' ) { - lastElement = positionParent; - - if ( isFirstBlock && !deleteContent ) { - // For the "c" as an anchorElement: - // * a - // * b - // * [c] <-- this block should be merged with "a" - // It should find "a" element to merge with: - // * a - // * b - // c - firstElement = ListWalker.first( positionParent, { sameIndent: true, lowerIndent: true } ); - } else { - firstElement = positionParent.previousSibling; - } - } else { - // In case of the forward merge there is no case as above, just merge with next sibling. - firstElement = positionParent; - lastElement = positionParent.nextSibling; - } - } else { - firstElement = selection.getFirstPosition().parent; - lastElement = selection.getLastPosition().parent; - } + const shouldMergeOnBlocksContentLevel = this._shouldMergeOnBlocksContentLevel(); + const { firstElement, lastElement } = this._getBoundaryElements( selection, shouldMergeOnBlocksContentLevel ); const firstIndent = firstElement.getAttribute( 'listIndent' ) || 0; const lastIndent = lastElement.getAttribute( 'listIndent' ); @@ -109,7 +82,7 @@ export default class DocumentListMergeCommand extends Command { } ) ); } - if ( deleteContent ) { + if ( shouldMergeOnBlocksContentLevel ) { let sel = selection; if ( selection.isCollapsed ) { @@ -171,33 +144,111 @@ export default class DocumentListMergeCommand extends Command { _checkEnabled() { const model = this.editor.model; const selection = model.document.selection; - const firstPosition = selection.getFirstPosition(); - const firstPositionParent = firstPosition.parent; - // TODO refactor this; it does not depend on where exactly in the list block the selection is + const shouldMergeOnBlocksContentLevel = this._shouldMergeOnBlocksContentLevel(); + const { firstElement, lastElement } = this._getBoundaryElements( selection, shouldMergeOnBlocksContentLevel ); - let firstNode; - - if ( selection.isCollapsed ) { - firstNode = firstPosition.isAtEnd ? firstPositionParent.nextSibling : firstPositionParent.previousSibling; + if ( shouldMergeOnBlocksContentLevel ) { + return isListItemBlock( lastElement ); + // return isListItemBlock( firstElement ) && isListItemBlock( lastElement ); } else { - firstNode = firstPositionParent; + return isListItemBlock( firstElement ); } - const lastNode = selection.getLastPosition().parent; + // let sel = selection; - if ( firstNode === lastNode ) { - return false; + // if ( selection.isCollapsed ) { + // // TODO what if one of blocks is an object (for example a table or block image)? + // sel = writer.createSelection( writer.createRange( + // writer.createPositionAt( firstElement, 'end' ), + // writer.createPositionAt( lastElement, 0 ) + // ) ); + // } + + // // Delete selected content. Replace entire content only for non-collapsed selection. + // model.deleteContent( sel, { doNotResetEntireContent: selection.isCollapsed } ); + + // // Get the last "touched" element after deleteContent call (can't use the lastElement because + // // it could get merged into the firstElement while deleting content). + // const lastElementAfterDelete = sel.getLastPosition().parent; + + // // Check if the element after it was in the same list item and adjust it if needed. + // const nextSibling = lastElementAfterDelete.nextSibling; + + // changedBlocks.push( lastElementAfterDelete ); + + // if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { + // changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); + // } + } + + /** + * + * @returns TODO + */ + _shouldMergeOnBlocksContentLevel() { + const model = this.editor.model; + const selection = model.document.selection; + + if ( !selection.isCollapsed || this._direction === 'forward' ) { + return true; } - if ( !firstNode || !lastNode.hasAttribute( 'listItemId' ) ) { + const firstPosition = selection.getFirstPosition(); + const positionParent = firstPosition.parent; + const previousSibling = positionParent.previousSibling; + + if ( model.schema.isObject( previousSibling ) ) { return false; } - if ( selection.isCollapsed && !( firstPosition.isAtStart || firstPosition.isAtEnd ) ) { - return false; + if ( previousSibling.isEmpty ) { + return true; + } + + return isSingleListItem( [ positionParent, previousSibling ] ); + } + + /** + * TODO + * + * @param {*} selection + * @param {*} shouldMergeOnBlocksContentLevel + * @returns + */ + _getBoundaryElements( selection, shouldMergeOnBlocksContentLevel ) { + let firstElement, lastElement; + + if ( selection.isCollapsed ) { + const positionParent = selection.getFirstPosition().parent; + const isFirstBlock = isFirstBlockOfListItem( positionParent ); + + if ( this._direction == 'backward' ) { + lastElement = positionParent; + + if ( isFirstBlock && !shouldMergeOnBlocksContentLevel ) { + // For the "c" as an anchorElement: + // * a + // * b + // * [c] <-- this block should be merged with "a" + // It should find "a" element to merge with: + // * a + // * b + // c + firstElement = ListWalker.first( positionParent, { sameIndent: true, lowerIndent: true } ); + } else { + firstElement = positionParent.previousSibling; + } + } else { + // In case of the forward merge there is no case as above, just merge with next sibling. + firstElement = positionParent; + lastElement = positionParent.nextSibling; + } + } else { + firstElement = selection.getFirstPosition().parent; + lastElement = selection.getLastPosition().parent; } - return true; + return { firstElement, lastElement }; } } diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 9c0ebe210ef..99f5ed90d8b 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -25,7 +25,7 @@ import stubUid from '../_utils/uid'; import { modelList } from '../_utils/utils'; import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubblingeventinfo'; -describe( 'DocumentListEditing integrations: backspace & delete', () => { +describe.only( 'DocumentListEditing integrations: backspace & delete', () => { const blocksChangedByCommands = []; let editor, model, view; From 253f68c03f5c380059a5ef128d2df93a64fc36d7 Mon Sep 17 00:00:00 2001 From: Kuba Niegowski Date: Thu, 27 Jan 2022 13:06:56 +0100 Subject: [PATCH 23/44] WiP. --- .../src/documentlist/documentlistediting.js | 36 ++++------- .../documentlist/documentlistmergecommand.js | 59 ++++++++----------- .../tests/documentlist/integrations/delete.js | 38 +++++++----- 3 files changed, 61 insertions(+), 72 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 51444507c49..b28d6969a25 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -32,8 +32,7 @@ import { import { getAllListItemBlocks, isFirstBlockOfListItem, - isLastBlockOfListItem, - isSingleListItem + isLastBlockOfListItem } from './utils/model'; import ListWalker, { iterateSiblingListBlocks } from './utils/listwalker'; @@ -130,18 +129,13 @@ export default class DocumentListEditing extends Plugin { } // Merge block with previous one (on the block level or on the content level). else { - const previousSibling = positionParent.previousSibling; - const isInsideSingleListItem = isSingleListItem( [ positionParent, previousSibling ] ); + const mergeListItemCommand = editor.commands.get( 'mergeListItemBackward' ); - if ( model.schema.isObject( previousSibling ) ) { - if ( isInsideSingleListItem ) { - return; - } - - editor.execute( 'mergeListItemBackward' ); - } else { - editor.execute( 'mergeListItemBackward' ); + if ( !mergeListItemCommand.isEnabled ) { + return; } + + mergeListItemCommand.execute(); } data.preventDefault(); @@ -149,26 +143,18 @@ export default class DocumentListEditing extends Plugin { } // Non-collapsed selection or forward delete. else { - const lastPosition = selection.getLastPosition(); - const positionParent = lastPosition.parent; - // Collapsed selection should trigger forward merging only if at the end of a block. - if ( selection.isCollapsed && !lastPosition.isAtEnd ) { + if ( selection.isCollapsed && !selection.getLastPosition().isAtEnd ) { return; } - // The list bocks merging is required only if the selection ends in the list item - // (in case of fixing the indents of following list items). - if ( !positionParent.hasAttribute( 'listItemId' ) ) { + const mergeListItemCommand = editor.commands.get( 'mergeListItemForward' ); + + if ( !mergeListItemCommand.isEnabled ) { return; } - // TODO let the widget handler do its stuff - // if ( model.schema.isObject( positionParent.nextSibling ) ) { - // return; - // } - - editor.execute( 'mergeListItemForward' ); + mergeListItemCommand.execute(); data.preventDefault(); evt.stop(); diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 8392bbfda4d..4ca98bec3a0 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -14,8 +14,7 @@ import { sortBlocks, isFirstBlockOfListItem, mergeListItemBefore, - isSingleListItem, - isListItemBlock + isSingleListItem } from './utils/model'; import ListWalker from './utils/listwalker'; @@ -65,7 +64,7 @@ export default class DocumentListMergeCommand extends Command { model.change( writer => { const shouldMergeOnBlocksContentLevel = this._shouldMergeOnBlocksContentLevel(); - const { firstElement, lastElement } = this._getBoundaryElements( selection, shouldMergeOnBlocksContentLevel ); + const { firstElement, lastElement } = this._getMergeSubjectElements( selection, shouldMergeOnBlocksContentLevel ); const firstIndent = firstElement.getAttribute( 'listIndent' ) || 0; const lastIndent = lastElement.getAttribute( 'listIndent' ); @@ -145,41 +144,35 @@ export default class DocumentListMergeCommand extends Command { const model = this.editor.model; const selection = model.document.selection; - const shouldMergeOnBlocksContentLevel = this._shouldMergeOnBlocksContentLevel(); - const { firstElement, lastElement } = this._getBoundaryElements( selection, shouldMergeOnBlocksContentLevel ); - - if ( shouldMergeOnBlocksContentLevel ) { - return isListItemBlock( lastElement ); - // return isListItemBlock( firstElement ) && isListItemBlock( lastElement ); - } else { - return isListItemBlock( firstElement ); - } - - // let sel = selection; + if ( selection.isCollapsed ) { + const firstPosition = selection.getFirstPosition(); + const positionParent = firstPosition.parent; - // if ( selection.isCollapsed ) { - // // TODO what if one of blocks is an object (for example a table or block image)? - // sel = writer.createSelection( writer.createRange( - // writer.createPositionAt( firstElement, 'end' ), - // writer.createPositionAt( lastElement, 0 ) - // ) ); - // } + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return false; + } - // // Delete selected content. Replace entire content only for non-collapsed selection. - // model.deleteContent( sel, { doNotResetEntireContent: selection.isCollapsed } ); + const siblingNode = this._direction == 'backward' ? + positionParent.previousSibling : + positionParent.nextSibling; - // // Get the last "touched" element after deleteContent call (can't use the lastElement because - // // it could get merged into the firstElement while deleting content). - // const lastElementAfterDelete = sel.getLastPosition().parent; + if ( !siblingNode ) { + return false; + } - // // Check if the element after it was in the same list item and adjust it if needed. - // const nextSibling = lastElementAfterDelete.nextSibling; + if ( isSingleListItem( [ positionParent, siblingNode ] ) ) { + return false; + } + } else { + const lastPosition = selection.getLastPosition(); + const positionParent = lastPosition.parent; - // changedBlocks.push( lastElementAfterDelete ); + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return false; + } + } - // if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { - // changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); - // } + return true; } /** @@ -216,7 +209,7 @@ export default class DocumentListMergeCommand extends Command { * @param {*} shouldMergeOnBlocksContentLevel * @returns */ - _getBoundaryElements( selection, shouldMergeOnBlocksContentLevel ) { + _getMergeSubjectElements( selection, shouldMergeOnBlocksContentLevel ) { let firstElement, lastElement; if ( selection.isCollapsed ) { diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 99f5ed90d8b..4f7ec395428 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -25,7 +25,7 @@ import stubUid from '../_utils/uid'; import { modelList } from '../_utils/utils'; import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubblingeventinfo'; -describe.only( 'DocumentListEditing integrations: backspace & delete', () => { +describe( 'DocumentListEditing integrations: backspace & delete', () => { const blocksChangedByCommands = []; let editor, model, view; @@ -71,10 +71,15 @@ describe.only( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackwardCommand = editor.commands.get( 'mergeListItemBackward' ); mergeForwardCommand = editor.commands.get( 'mergeListItemForward' ); - splitAfterCommandExecuteSpy = sinon.spy( splitAfterCommand, 'execute' ); - outdentCommandExecuteSpy = sinon.spy( outdentCommand, 'execute' ); - mergeBackwardCommandExecuteSpy = sinon.spy( mergeBackwardCommand, 'execute' ); - mergeForwardCommandExecuteSpy = sinon.spy( mergeForwardCommand, 'execute' ); + splitAfterCommandExecuteSpy = sinon.spy(); + outdentCommandExecuteSpy = sinon.spy(); + mergeBackwardCommandExecuteSpy = sinon.spy(); + mergeForwardCommandExecuteSpy = sinon.spy(); + + splitAfterCommand.on( 'execute', splitAfterCommandExecuteSpy ); + outdentCommand.on( 'execute', outdentCommandExecuteSpy ); + mergeBackwardCommand.on( 'execute', mergeBackwardCommandExecuteSpy ); + mergeForwardCommand.on( 'execute', mergeForwardCommandExecuteSpy ); commandSpies = { outdent: outdentCommandExecuteSpy, @@ -2793,23 +2798,25 @@ describe.only( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'single block list item', () => { describe( 'collapsed selection at the end of a list item', () => { describe( 'item after is empty', () => { - // TODO: This should be handled by #isEnabled. - it( 'should remove list when in empty only element of a list', () => { + it( 'should not remove list when in empty only element of a list', () => { runTest( { input: [ '* []' ], expected: [ - '[]' + '* []' ], - eventStopped: true, + eventStopped: { + preventDefault: true, + stop: false + }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 1 + mergeForward: 0 }, - changedBlocks: [ 1 ] + changedBlocks: [] } ); } ); @@ -3578,14 +3585,17 @@ describe.only( 'DocumentListEditing integrations: backspace & delete', () => { expected: [ '* []a' ], - eventStopped: true, + eventStopped: { + preventDefault: true, + stop: false + }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 1 + mergeForward: 0 }, - changedBlocks: [ 0 ] + changedBlocks: [] } ); } ); From c7b3a7fa921c2622e67c52d5ecbb74a097829f7b Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Thu, 27 Jan 2022 13:49:20 +0100 Subject: [PATCH 24/44] Code refactoring. --- .../src/documentlist/documentlistediting.js | 131 ++++++++++-------- 1 file changed, 77 insertions(+), 54 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index b28d6969a25..3628f9a88d3 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -64,8 +64,6 @@ export default class DocumentListEditing extends Plugin { init() { const editor = this.editor; const model = editor.model; - const commands = editor.commands; - const enterCommand = commands.get( 'enter' ); if ( editor.plugins.has( 'ListEditing' ) ) { /** @@ -85,8 +83,6 @@ export default class DocumentListEditing extends Plugin { model.on( 'insertContent', createModelIndentPasteFixer( model ), { priority: 'high' } ); - this._setupConversion(); - // Register commands. editor.commands.add( 'numberedList', new DocumentListCommand( editor, 'numbered' ) ); editor.commands.add( 'bulletedList', new DocumentListCommand( editor, 'bulleted' ) ); @@ -100,6 +96,70 @@ export default class DocumentListEditing extends Plugin { editor.commands.add( 'splitListItemBefore', new DocumentListSplitCommand( editor, 'before' ) ); editor.commands.add( 'splitListItemAfter', new DocumentListSplitCommand( editor, 'after' ) ); + this._setupConversion(); + this._setupDeleteIntegration(); + this._setupEnterIntegration(); + } + + /** + * @inheritDoc + */ + afterInit() { + const editor = this.editor; + const commands = editor.commands; + const indent = commands.get( 'indent' ); + const outdent = commands.get( 'outdent' ); + + if ( indent ) { + indent.registerChildCommand( commands.get( 'indentList' ) ); + } + + if ( outdent ) { + outdent.registerChildCommand( commands.get( 'outdentList' ) ); + } + } + + /** + * Registers the conversion helpers for the document-list feature. + * @private + */ + _setupConversion() { + const editor = this.editor; + const model = editor.model; + const attributes = [ 'listItemId', 'listType', 'listIndent' ]; + + editor.conversion.for( 'upcast' ) + .elementToElement( { view: 'li', model: 'paragraph' } ) + .add( dispatcher => { + dispatcher.on( 'element:li', listItemUpcastConverter() ); + dispatcher.on( 'element:ul', listUpcastCleanList(), { priority: 'high' } ); + dispatcher.on( 'element:ol', listUpcastCleanList(), { priority: 'high' } ); + } ); + + editor.conversion.for( 'editingDowncast' ).add( dispatcher => downcastConverters( dispatcher ) ); + editor.conversion.for( 'dataDowncast' ).add( dispatcher => downcastConverters( dispatcher, { dataPipeline: true } ) ); + + function downcastConverters( dispatcher, options = {} ) { + dispatcher.on( 'insert:paragraph', listItemParagraphDowncastConverter( attributes, model, options ), { priority: 'high' } ); + + for ( const attributeName of attributes ) { + dispatcher.on( `attribute:${ attributeName }`, listItemDowncastConverter( attributes, model ) ); + } + } + + editor.data.mapper.registerViewToModelLength( 'li', listItemViewToModelLengthMapper( editor.data.mapper, model.schema ) ); + this.listenTo( model.document, 'change:data', reconvertItemsOnDataChange( model, editor.editing ) ); + } + + /** + * Attaches the listener to the {@link module:engine/view/document~Document#event:delete} event and handles backspace/delete + * keys in and around document lists. + * + * @private + */ + _setupDeleteIntegration() { + const editor = this.editor; + this.listenTo( editor.editing.view.document, 'delete', ( evt, data ) => { const selection = editor.model.document.selection; @@ -161,6 +221,19 @@ export default class DocumentListEditing extends Plugin { } } ); }, { context: 'li' } ); + } + + /** + * Attaches a listener to the {@link module:engine/view/document~Document#event:enter} event and handles enter key press + * in document lists. + * + * @private + */ + _setupEnterIntegration() { + const editor = this.editor; + const model = editor.model; + const commands = editor.commands; + const enterCommand = commands.get( 'enter' ); // Overwrite the default Enter key behavior: outdent or split the list in certain cases. this.listenTo( editor.editing.view.document, 'enter', ( evt, data ) => { @@ -226,56 +299,6 @@ export default class DocumentListEditing extends Plugin { } } ); } - - /** - * @inheritDoc - */ - afterInit() { - const editor = this.editor; - const commands = editor.commands; - const indent = commands.get( 'indent' ); - const outdent = commands.get( 'outdent' ); - - if ( indent ) { - indent.registerChildCommand( commands.get( 'indentList' ) ); - } - - if ( outdent ) { - outdent.registerChildCommand( commands.get( 'outdentList' ) ); - } - } - - /** - * Registers the conversion helpers for the document-list feature. - * @private - */ - _setupConversion() { - const editor = this.editor; - const model = editor.model; - const attributes = [ 'listItemId', 'listType', 'listIndent' ]; - - editor.conversion.for( 'upcast' ) - .elementToElement( { view: 'li', model: 'paragraph' } ) - .add( dispatcher => { - dispatcher.on( 'element:li', listItemUpcastConverter() ); - dispatcher.on( 'element:ul', listUpcastCleanList(), { priority: 'high' } ); - dispatcher.on( 'element:ol', listUpcastCleanList(), { priority: 'high' } ); - } ); - - editor.conversion.for( 'editingDowncast' ).add( dispatcher => downcastConverters( dispatcher ) ); - editor.conversion.for( 'dataDowncast' ).add( dispatcher => downcastConverters( dispatcher, { dataPipeline: true } ) ); - - function downcastConverters( dispatcher, options = {} ) { - dispatcher.on( 'insert:paragraph', listItemParagraphDowncastConverter( attributes, model, options ), { priority: 'high' } ); - - for ( const attributeName of attributes ) { - dispatcher.on( `attribute:${ attributeName }`, listItemDowncastConverter( attributes, model ) ); - } - } - - editor.data.mapper.registerViewToModelLength( 'li', listItemViewToModelLengthMapper( editor.data.mapper, model.schema ) ); - this.listenTo( model.document, 'change:data', reconvertItemsOnDataChange( model, editor.editing ) ); - } } // Post-fixer that reacts to changes on document and fixes incorrect model states (invalid `listItemId` and `listIndent` values). From 9adc93eddb9933a3f2a6db0b4f8d02217683c189 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Thu, 27 Jan 2022 18:09:38 +0100 Subject: [PATCH 25/44] Allowed selected objects and nested elements to be passed into modelList(). --- packages/ckeditor5-list/package.json | 1 + .../tests/documentlist/_utils-tests/utils.js | 104 ++++++++++++++++++ .../tests/documentlist/_utils/utils.js | 42 ++++++- 3 files changed, 143 insertions(+), 4 deletions(-) diff --git a/packages/ckeditor5-list/package.json b/packages/ckeditor5-list/package.json index 6682202e3db..83612411696 100644 --- a/packages/ckeditor5-list/package.json +++ b/packages/ckeditor5-list/package.json @@ -48,6 +48,7 @@ "@ckeditor/ckeditor5-typing": "^31.1.0", "@ckeditor/ckeditor5-undo": "^31.1.0", "@ckeditor/ckeditor5-utils": "^31.1.0", + "@ckeditor/ckeditor5-widget": "^31.1.0", "webpack": "^5.58.1", "webpack-cli": "^4.9.0" }, diff --git a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js index 2616d811ff0..0ec8cf4f598 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js @@ -226,6 +226,110 @@ describe( 'mockList()', () => { ); } ); + it( 'should allow passing custom element (no selection)', () => { + expect( modelList( [ + '* ' + ] ) ).to.equalMarkup( + '' + ); + } ); + + it( 'should allow passing custom element (self closing, no attributes)', () => { + expect( modelList( [ + '* ' + ] ) ).to.equalMarkup( + '' + ); + } ); + + it( 'should allow passing custom element (self closing, with attributes)', () => { + expect( modelList( [ + '* ' + ] ) ).to.equalMarkup( + '' + ); + } ); + + it( 'should allow passing custom element (empty)', () => { + expect( modelList( [ + '* []', + '* bar' + ] ) ).to.equalMarkup( + '[]' + + 'bar' + ); + } ); + + it( 'should allow passing custom element (nested)', () => { + expect( modelList( [ + '* []', + '* bar' + ] ) ).to.equalMarkup( + '[]' + + 'bar' + ); + } ); + + it( 'should allow passing custom element (nested mixed)', () => { + expect( modelList( [ + '* [ab]', + '* bar' + ] ) ).to.equalMarkup( + '[ab]' + + 'bar' + ); + } ); + + it( 'should allow passing custom element (selected)', () => { + expect( modelList( [ + '* [foo]', + '* bar' + ] ) ).to.equalMarkup( + '[foo]' + + 'bar' + ); + } ); + + it( 'should allow passing custom element (selection starts before)', () => { + expect( modelList( [ + '* [foo', + '* bar]' + ] ) ).to.equalMarkup( + '[foo' + + 'bar]' + ); + } ); + + it( 'should allow passing custom element (selection ends before)', () => { + expect( modelList( [ + '* [bar', + '* ]foo' + ] ) ).to.equalMarkup( + '[bar]' + + 'foo' + ); + } ); + + it( 'should allow passing custom element (selection starts after)', () => { + expect( modelList( [ + '* foo[', + '* bar]' + ] ) ).to.equalMarkup( + 'foo' + + '[bar]' + ); + } ); + + it( 'should allow passing custom element (selection ends after)', () => { + expect( modelList( [ + '* [bar', + '* foo]' + ] ) ).to.equalMarkup( + '[bar' + + 'foo]' + ); + } ); + it( 'should allow to customize the list item id (suffix)', () => { expect( modelList( [ '* foo{abc}', diff --git a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js index b4be24242c1..9d810e61d37 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js @@ -324,9 +324,43 @@ function stringifyNode( node, writer ) { return stringifyModel( fragment ); } -function stringifyElement( content, attributes = {}, name = 'paragraph' ) { - [ , name, content ] = content.match( /^<([^>]+)>([^<]*)?/ ) || [ null, name, content ]; - attributes = Object.entries( attributes ).map( ( [ key, value ] ) => ` ${ key }="${ value }"` ).join( '' ); +function stringifyElement( content, listAttributes = {} ) { + let name = 'paragraph'; + let elementAttributes = ''; + let selectionBefore = ''; + let selectionAfter = ''; + + const regexp = new RegExp( + '^(?[\\[\\]])?' + // [\\w+)(?[^>]+)?/>' + // For instance OR + '|' + + '<(?\\w+)(?[^>]+)?>' + // For instance OR ... + '(?.*)' + + '(?:)' + // Note: Match here in the closing tag. + ')' + + '(?[\\[\\]])?$' // ] or ] + ); + + const match = content.match( regexp ); + + if ( match ) { + name = match.groups.nameSelfClosing || match.groups.name; + elementAttributes = match.groups.elementAttributes || match.groups.elementSelfClosingAttributes || ''; + content = match.groups.content || ''; + + if ( match.groups.selectionBefore ) { + selectionBefore = match.groups.selectionBefore; + } + + if ( match.groups.selectionAfter ) { + selectionAfter = match.groups.selectionAfter; + } + } + + listAttributes = Object.entries( listAttributes ).map( ( [ key, value ] ) => ` ${ key }="${ value }"` ).join( '' ); - return `<${ name }${ attributes }>${ content }`; + return `${ selectionBefore }` + + `<${ name }${ elementAttributes }${ listAttributes }>${ content }` + + `${ selectionAfter }`; } From 12f5cfd869320af99f33e04d6e29d3a9c64b8143 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Thu, 27 Jan 2022 18:12:23 +0100 Subject: [PATCH 26/44] Added block and inline widgets to the list mocking manual test. --- .../tests/manual/listmocking.html | 15 ++++++++ .../tests/manual/listmocking.js | 34 ++++++++++++++++++- 2 files changed, 48 insertions(+), 1 deletion(-) diff --git a/packages/ckeditor5-list/tests/manual/listmocking.html b/packages/ckeditor5-list/tests/manual/listmocking.html index 4efb7417aac..c369169a17f 100644 --- a/packages/ckeditor5-list/tests/manual/listmocking.html +++ b/packages/ckeditor5-list/tests/manual/listmocking.html @@ -58,6 +58,21 @@ padding: 5px; margin: 5px; } + + .block-widget { + width: 100%; + height: 50px; + background: hsl(120deg 54% 57%); + display: block; + } + + .inline-widget { + width: 25px; + height: 25px; + background: hsl(303, 82%, 41%); + display: inline-block; + margin: 0 5px; + }

    Input

    diff --git a/packages/ckeditor5-list/tests/manual/listmocking.js b/packages/ckeditor5-list/tests/manual/listmocking.js index a71ef57491c..ba2c98386d4 100644 --- a/packages/ckeditor5-list/tests/manual/listmocking.js +++ b/packages/ckeditor5-list/tests/manual/listmocking.js @@ -13,6 +13,8 @@ import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph'; import Undo from '@ckeditor/ckeditor5-undo/src/undo'; import Clipboard from '@ckeditor/ckeditor5-clipboard/src/clipboard'; import Indent from '@ckeditor/ckeditor5-indent/src/indent'; +import Widget from '@ckeditor/ckeditor5-widget/src/widget'; +import { toWidget } from '@ckeditor/ckeditor5-widget/src/utils'; import { parse as parseModel, setData as setModelData, @@ -24,12 +26,42 @@ import DocumentList from '../../src/documentlist'; ClassicEditor .create( document.querySelector( '#editor' ), { - plugins: [ Enter, Typing, Heading, Paragraph, Undo, Clipboard, DocumentList, Indent ], + plugins: [ Enter, Typing, Heading, Paragraph, Undo, Clipboard, DocumentList, Indent, Widget ], toolbar: [ 'heading', '|', 'bulletedList', 'numberedList', 'outdent', 'indent', '|', 'undo', 'redo' ] } ) .then( editor => { window.editor = editor; + editor.model.schema.register( 'blockWidget', { + isObject: true, + allowIn: '$root', + allowAttributesOf: '$container' + } ); + + editor.conversion.for( 'upcast' ).elementToElement( { model: 'blockWidget', view: 'blockwidget' } ); + + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'blockWidget', + view: ( modelItem, { writer } ) => { + return toWidget( writer.createContainerElement( 'blockwidget', { class: 'block-widget' } ), writer ); + } + } ); + + editor.model.schema.register( 'inlineWidget', { + isObject: true, + isInline: true, + allowWhere: '$text', + allowAttributesOf: '$text' + } ); + + // The view element has no children. + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'inlineWidget', + view: ( modelItem, { writer } ) => toWidget( + writer.createContainerElement( 'inlinewidget', { class: 'inline-widget' } ), writer, { label: 'inline widget' } + ) + } ); + const model = 'A\n' + 'B\n' + 'C\n' + From 087691460999cd8e9ff26b9fcbe1a7da29c4c825 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Thu, 27 Jan 2022 18:13:44 +0100 Subject: [PATCH 27/44] WIP: Added block&inline widget tests to the DocumentListEditing backspace/delete integration. --- .../tests/documentlist/integrations/delete.js | 509 +++++++++++++++++- 1 file changed, 493 insertions(+), 16 deletions(-) diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 4f7ec395428..3a5ba76aa1a 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -3,18 +3,17 @@ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ +/* global document */ + import DocumentListEditing from '../../../src/documentlist/documentlistediting'; -import BoldEditing from '@ckeditor/ckeditor5-basic-styles/src/bold/boldediting'; -import UndoEditing from '@ckeditor/ckeditor5-undo/src/undoediting'; -import ClipboardPipeline from '@ckeditor/ckeditor5-clipboard/src/clipboardpipeline'; -import BlockQuoteEditing from '@ckeditor/ckeditor5-block-quote/src/blockquoteediting'; -import HeadingEditing from '@ckeditor/ckeditor5-heading/src/headingediting'; -import TableEditing from '@ckeditor/ckeditor5-table/src/tableediting'; +import Delete from '@ckeditor/ckeditor5-typing/src/delete'; import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph'; +import Widget from '@ckeditor/ckeditor5-widget/src/widget'; +import { toWidget } from '@ckeditor/ckeditor5-widget/src/utils'; import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; -import VirtualTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/virtualtesteditor'; +import ClassicTestEditor from '@ckeditor/ckeditor5-core/tests/_utils/classictesteditor'; import { getData as getModelData, setData as setModelData @@ -28,6 +27,7 @@ import BubblingEventInfo from '@ckeditor/ckeditor5-engine/src/view/observer/bubb describe( 'DocumentListEditing integrations: backspace & delete', () => { const blocksChangedByCommands = []; + let element; let editor, model, view; let eventInfo, domEventData; let mergeBackwardCommand, mergeForwardCommand, splitAfterCommand, outdentCommand, @@ -37,10 +37,12 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { testUtils.createSinonSandbox(); beforeEach( async () => { - editor = await VirtualTestEditor.create( { + element = document.createElement( 'div' ); + document.body.appendChild( element ); + + editor = await ClassicTestEditor.create( element, { plugins: [ - Paragraph, ClipboardPipeline, BoldEditing, DocumentListEditing, UndoEditing, - BlockQuoteEditing, TableEditing, HeadingEditing + DocumentListEditing, Paragraph, Delete, Widget ] } ); @@ -51,14 +53,33 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { allowAttributes: 'foo' } ); - model.schema.register( 'nonListable', { - allowWhere: '$block', - allowContentOf: '$block', - inheritTypesFrom: '$block', - allowAttributes: 'foo' + model.schema.register( 'blockWidget', { + isObject: true, + allowIn: '$root', + allowAttributesOf: '$container' + } ); + + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'blockWidget', + view: ( modelItem, { writer } ) => { + return toWidget( writer.createContainerElement( 'blockwidget', { class: 'block-widget' } ), writer ); + } + } ); + + editor.model.schema.register( 'inlineWidget', { + isObject: true, + isInline: true, + allowWhere: '$text', + allowAttributesOf: '$text' } ); - editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); + // The view element has no children. + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'inlineWidget', + view: ( modelItem, { writer } ) => toWidget( + writer.createContainerElement( 'inlinewidget', { class: 'inline-widget' } ), writer, { label: 'inline widget' } + ) + } ); // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); @@ -108,6 +129,8 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); afterEach( async () => { + element.remove(); + await editor.destroy(); } ); @@ -2782,6 +2805,460 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); } ); + + describe( 'around widgets', () => { + describe( 'block widgets', () => { + it( 'TODO 1', () => { + runTest( { + input: [ + '* ', + '[]' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 1a', () => { + runTest( { + input: [ + '* a', + ' ', + '[]' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 1b', () => { + runTest( { + input: [ + '* a', + ' * ', + '[]' + ], + expected: [ + '* a', + ' * []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 2', () => { + runTest( { + input: [ + '* a', + ' ', + '* []' + ], + expected: [ + '* a', + ' ', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); + } ); + + it( 'TODO 3', () => { + runTest( { + input: [ + '* a', + ' * ', + '* []' + ], + expected: [ + '* a', + ' * ', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); + } ); + + it( 'TODO 4', () => { + runTest( { + input: [ + '* a', + ' * ', + ' * []' + ], + expected: [ + '* a', + ' * ', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 2 ] + } ); + } ); + + it( 'TODO 5', () => { + runTest( { + input: [ + '* a', + ' b', + ' ', + ' []' + ], + expected: [ + '* a', + ' b', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 6', () => { + runTest( { + input: [ + '* a', + ' []' + ], + expected: [ + '* a[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 6a', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a[]', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 6b', () => { + runTest( { + input: [ + '* a', + ' []', + ' * b' + ], + expected: [ + '* a[]', + ' * b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 7', () => { + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 7a', () => { + runTest( { + input: [ + '* a', + ' * []', + ' b' + ], + expected: [ + '* a[]', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 8', () => { + runTest( { + input: [ + '* a[', + ' ]' + ], + expected: [ + '* a[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 9', () => { + runTest( { + input: [ + '* [a', + ' ]' + ], + expected: [ + '[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'TODO 10', () => { + runTest( { + input: [ + '* [a', + ' * ]' + ], + expected: [ + '[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + } ); + + describe( 'inline images', () => { + it( 'INTODO 0', () => { + runTest( { + input: [ + '* []' + ], + expected: [ + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'INTODO 1', () => { + runTest( { + input: [ + '* a', + '[]' + ], + expected: [ + '* a[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'INTODO 2', () => { + runTest( { + input: [ + '* a', + '* []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 1, + mergeForward: 0 + }, + changedBlocks: [ 1 ] + } ); + } ); + + it( 'INTODO 3', () => { + runTest( { + input: [ + '* a[]' + ], + expected: [ + '* a[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'INTODO 4', () => { + runTest( { + input: [ + '* a[]' + ], + expected: [ + '* a[]' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + } ); + } ); } ); describe( 'delete (forward)', () => { From 8e3e4807528414d1575f51043cfeaeaeb74bdd24 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 1 Feb 2022 12:51:39 +0100 Subject: [PATCH 28/44] Implemented delete/backspace handling in document lists around block and inline widgets. --- .../documentlist/documentlistmergecommand.js | 93 +- .../tests/documentlist/integrations/delete.js | 923 +++++++++++++++++- 2 files changed, 947 insertions(+), 69 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 4ca98bec3a0..0be3473736b 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -82,30 +82,48 @@ export default class DocumentListMergeCommand extends Command { } if ( shouldMergeOnBlocksContentLevel ) { - let sel = selection; - - if ( selection.isCollapsed ) { - // TODO what if one of blocks is an object (for example a table or block image)? - sel = writer.createSelection( writer.createRange( - writer.createPositionAt( firstElement, 'end' ), - writer.createPositionAt( lastElement, 0 ) - ) ); - } + const selectedElement = selection.getSelectedElement(); + + if ( selectedElement ) { + const listItemId = selectedElement.getAttribute( 'listItemId' ); + const listType = selectedElement.getAttribute( 'listType' ); + const listIndent = selectedElement.getAttribute( 'listIndent' ); + + model.deleteContent( selection, { + doNotResetEntireContent: false, + doNotAutoparagraph: false + } ); + + const lastElementAfterDelete = selection.getLastPosition().parent; + + writer.setAttributes( { listItemId, listType, listIndent }, lastElementAfterDelete ); + } else { + let sel = selection; + + if ( selection.isCollapsed ) { + sel = writer.createSelection( writer.createRange( + writer.createPositionAt( firstElement, 'end' ), + writer.createPositionAt( lastElement, 0 ) + ) ); + } - // Delete selected content. Replace entire content only for non-collapsed selection. - model.deleteContent( sel, { doNotResetEntireContent: selection.isCollapsed } ); + // Delete selected content. Replace entire content only for non-collapsed selection. + model.deleteContent( sel, { + doNotResetEntireContent: selection.isCollapsed + } ); - // Get the last "touched" element after deleteContent call (can't use the lastElement because - // it could get merged into the firstElement while deleting content). - const lastElementAfterDelete = sel.getLastPosition().parent; + // Get the last "touched" element after deleteContent call (can't use the lastElement because + // it could get merged into the firstElement while deleting content). + const lastElementAfterDelete = sel.getLastPosition().parent; - // Check if the element after it was in the same list item and adjust it if needed. - const nextSibling = lastElementAfterDelete.nextSibling; + // Check if the element after it was in the same list item and adjust it if needed. + const nextSibling = lastElementAfterDelete.nextSibling; - changedBlocks.push( lastElementAfterDelete ); + changedBlocks.push( lastElementAfterDelete ); - if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { - changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); + if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { + changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); + } } } else { changedBlocks.push( ...mergeListItemBefore( lastElement, firstElement, writer ) ); @@ -160,15 +178,34 @@ export default class DocumentListMergeCommand extends Command { return false; } + // [] + // * + // + // OR + // + // * [] + // * + if ( model.schema.isObject( siblingNode ) && this._direction == 'forward' ) { + return false; + } + if ( isSingleListItem( [ positionParent, siblingNode ] ) ) { return false; } } else { - const lastPosition = selection.getLastPosition(); - const positionParent = lastPosition.parent; + const selectedElement = selection.getSelectedElement(); - if ( !positionParent.hasAttribute( 'listItemId' ) ) { - return false; + if ( selectedElement ) { + if ( !selectedElement.hasAttribute( 'listItemId' ) ) { + return false; + } + } else { + const lastPosition = selection.getLastPosition(); + const positionParent = lastPosition.parent; + + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return false; + } } } @@ -238,8 +275,14 @@ export default class DocumentListMergeCommand extends Command { lastElement = positionParent.nextSibling; } } else { - firstElement = selection.getFirstPosition().parent; - lastElement = selection.getLastPosition().parent; + const selectedElement = selection.getSelectedElement(); + + if ( selectedElement ) { + firstElement = lastElement = selectedElement; + } else { + firstElement = selection.getFirstPosition().parent; + lastElement = selection.getLastPosition().parent; + } } return { firstElement, lastElement }; diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 3a5ba76aa1a..b215dbe102f 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -2808,7 +2808,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'around widgets', () => { describe( 'block widgets', () => { - it( 'TODO 1', () => { + it( 'should delete a paragraph and select a block widget in a list that precedes it', () => { runTest( { input: [ '* ', @@ -2828,7 +2828,28 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 1a', () => { + it( 'should select a block widget in a list that precedes a non-empty paragraph', () => { + runTest( { + input: [ + '* ', + '[]foo' + ], + expected: [ + '* []', + 'foo' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a paragraph and select a block widget at a deeper level (2nd block) in a list that precedes it', () => { runTest( { input: [ '* a', @@ -2850,7 +2871,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 1b', () => { + it( 'should delete a paragraph and select a block widget at a deeper level (1st block) in a list that precedes it', () => { runTest( { input: [ '* a', @@ -2872,7 +2893,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 2', () => { + it( 'should merge an item into the previous one despite a block widget precededing it', () => { runTest( { input: [ '* a', @@ -2895,7 +2916,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 3', () => { + it( 'should merge an item into the previous one despite a block widget precededing it at a deeper level', () => { runTest( { input: [ '* a', @@ -2918,7 +2939,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 4', () => { + it( 'should merge an item into the previous one (down) despite a block widget precededing it at a lower level', () => { runTest( { input: [ '* a', @@ -2941,7 +2962,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 5', () => { + it( 'should delete an item block and select a block widget that precedes it', () => { runTest( { input: [ '* a', @@ -2965,30 +2986,31 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 6', () => { + it( 'should delete a block widget and move the selection to the list item block that precedes it', () => { runTest( { input: [ '* a', ' []' ], expected: [ - '* a[]' + '* a', + ' []' ], eventStopped: { preventDefault: true, - stop: false + stop: true }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 0 + mergeForward: 1 }, changedBlocks: [] } ); } ); - it( 'TODO 6a', () => { + it( 'should delete a block widget and move the selection to the block that precedes it (multiple blocks)', () => { runTest( { input: [ '* a', @@ -2996,24 +3018,25 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' b' ], expected: [ - '* a[]', + '* a', + ' []', ' b' ], eventStopped: { preventDefault: true, - stop: false + stop: true }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 0 + mergeForward: 1 }, changedBlocks: [] } ); } ); - it( 'TODO 6b', () => { + it( 'should delete a block widget and move the selection to the block that precedes it (nested item follows)', () => { runTest( { input: [ '* a', @@ -3021,47 +3044,49 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' * b' ], expected: [ - '* a[]', - ' * b' + '* a', + ' []', + ' * b {id:002}' ], eventStopped: { preventDefault: true, - stop: false + stop: true }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 0 + mergeForward: 1 }, changedBlocks: [] } ); } ); - it( 'TODO 7', () => { + it( 'should delete a block widget and move the selection down to the (shallower) block that precedes it', () => { runTest( { input: [ '* a', ' * []' ], expected: [ - '* a[]' + '* a', + ' * []' ], eventStopped: { preventDefault: true, - stop: false + stop: true }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 0 + mergeForward: 1 }, changedBlocks: [] } ); } ); - it( 'TODO 7a', () => { + it( 'should delete a block widget and move the selection down to the block that precedes it (multiple blocks)', () => { runTest( { input: [ '* a', @@ -3069,9 +3094,33 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' b' ], expected: [ - '* a[]', + '* a', + ' * []', ' b' ], + eventStopped: { + preventDefault: true, + stop: true + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove list when its entire cotent is selected (including a block widget), same indentation levels', () => { + runTest( { + input: [ + '* [a', + ' ]' + ], + expected: [ + '[]' + ], eventStopped: { preventDefault: true, stop: false @@ -3086,14 +3135,16 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 8', () => { + it( 'should remove multiple list item blocks (including a block widget) within the selection, block follows', () => { runTest( { input: [ - '* a[', - ' ]' + '* [a', + ' ]', + ' b' ], expected: [ - '* a[]' + '* []', + ' b' ], eventStopped: { preventDefault: true, @@ -3109,14 +3160,16 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 9', () => { + it( 'should remove multiple list item blocks (including a block widget) within the selection, nested block follows', () => { runTest( { input: [ '* [a', - ' ]' + ' ]', + ' * b' ], expected: [ - '[]' + '* []', + ' * b {id:002}' ], eventStopped: { preventDefault: true, @@ -3132,7 +3185,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'TODO 10', () => { + it( 'should remove list when its entire cotent is selected (including a block widget), mixed indentation levels', () => { runTest( { input: [ '* [a', @@ -3154,10 +3207,110 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { changedBlocks: [] } ); } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, mixed indent levels', () => { + runTest( { + input: [ + '* [a', + ' * ]', + ' * b' + ], + expected: [ + '* []', + ' * b {id:002}' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, ' + + 'mixed indent levels, following block', () => { + runTest( { + input: [ + '* [a', + ' * ]', + ' b' + ], + expected: [ + '* []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, ' + + 'mixed indent levels, following block at a deeper level', () => { + runTest( { + input: [ + '* [a', + ' * ]', + ' b' + ], + expected: [ + '* []', + ' * b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove a block widget surrounded by block containing inline images at boundaries', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); } ); describe( 'inline images', () => { - it( 'INTODO 0', () => { + it( 'should remove an inline widget if only content of a block', () => { runTest( { input: [ '* []' @@ -3165,7 +3318,10 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { expected: [ '* []' ], - eventStopped: true, + eventStopped: { + preventDefault: true, + stop: false + }, executedCommands: { outdent: 0, splitAfter: 0, @@ -3176,7 +3332,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'INTODO 1', () => { + it( 'should merge a paragraph into preceding list containing an inline widget', () => { runTest( { input: [ '* a', @@ -3199,7 +3355,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'INTODO 2', () => { + it( 'should merge an empty list item into preceding list item containing an inline widget', () => { runTest( { input: [ '* a', @@ -3220,7 +3376,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'INTODO 3', () => { + it( 'should remove an inline widget in a list item block containing other content (before)', () => { runTest( { input: [ '* a[]' @@ -3228,7 +3384,10 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { expected: [ '* a[]' ], - eventStopped: true, + eventStopped: { + preventDefault: true, + stop: false + }, executedCommands: { outdent: 0, splitAfter: 0, @@ -3239,15 +3398,70 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'INTODO 4', () => { + it( 'should remove an inline widget in a list item block containing other content (after)', () => { runTest( { input: [ - '* a[]' + '* []a' ], expected: [ - '* a[]' + '* []a' ], - eventStopped: true, + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove an inline widget in a middle list item block', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove an inline widget in a nested list item block', () => { + runTest( { + input: [ + '* a', + ' * []', + ' b' + ], + expected: [ + '* a', + ' * []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, executedCommands: { outdent: 0, splitAfter: 0, @@ -4953,6 +5167,626 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); } ); + + describe( 'around widgets', () => { + describe( 'block widgets', () => { + it( 'should delete a paragraph and select a block widget in a list that follows it', () => { + runTest( { + input: [ + '[]', + '* ' + ], + expected: [ + '* [] {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should select a block widget in a list that follows a non-empty paragraph', () => { + runTest( { + input: [ + 'foo[]', + '* ' + ], + expected: [ + 'foo', + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a paragraph and select a block widget (1st block) in a list that follows it', () => { + runTest( { + input: [ + '[]', + '* ', + ' a' + ], + expected: [ + '* [] {id:001}', + ' a' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should merge an item into the next one despite a block widget following it', () => { + runTest( { + input: [ + '* []', + '* ', + ' a' + ], + expected: [ + '* [] {id:001}', + ' a' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should merge an item into the next one despite a block widget following it at a deeper level', () => { + runTest( { + input: [ + '* a', + '* []', + ' * ' + ], + expected: [ + '* a', + ' * [] {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete an item block and select a block widget that follows it', () => { + runTest( { + input: [ + '* a', + ' []', + ' ', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection to the list item block that follows it', () => { + runTest( { + input: [ + '* a', + ' []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: { + preventDefault: true, + stop: true + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection to the block that follows it (multiple blocks)', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: true + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection to the block that follows it (nested item follows)', () => { + runTest( { + input: [ + '* a', + ' []', + ' * b' + ], + expected: [ + '* a', + ' []', + ' * b {id:002}' + ], + eventStopped: { + preventDefault: true, + stop: true + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection down to the (shallower) block that follows it', () => { + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a', + ' * []' + ], + eventStopped: { + preventDefault: true, + stop: true + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection down to the block that follows it (multiple blocks)', () => { + runTest( { + input: [ + '* a', + ' * []', + ' b' + ], + expected: [ + '* a', + ' * []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: true + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove list when its entire cotent is selected (including a block widget), same indentation levels', () => { + runTest( { + input: [ + '* [a', + ' ]' + ], + expected: [ + '[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, block follows', () => { + runTest( { + input: [ + '* [a', + ' ]', + ' b' + ], + expected: [ + '* []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, nested block follows', () => { + runTest( { + input: [ + '* [a', + ' ]', + ' * b' + ], + expected: [ + '* []', + ' * b {id:002}' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove list when its entire cotent is selected (including a block widget), mixed indentation levels', () => { + runTest( { + input: [ + '* [a', + ' * ]' + ], + expected: [ + '[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, mixed indent levels', () => { + runTest( { + input: [ + '* [a', + ' * ]', + ' * b' + ], + expected: [ + '* []', + ' * b {id:002}' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, ' + + 'mixed indent levels, following block', () => { + runTest( { + input: [ + '* [a', + ' * ]', + ' b' + ], + expected: [ + '* []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove multiple list item blocks (including a block widget) within the selection, ' + + 'mixed indent levels, following block at a deeper level', () => { + runTest( { + input: [ + '* [a', + ' * ]', + ' b' + ], + expected: [ + '* []', + ' * b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove a block widget surrounded by block containing inline images at boundaries', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + } ); + + describe( 'inline images', () => { + it( 'should remove an inline widget if only content of a block', () => { + runTest( { + input: [ + '* []' + ], + expected: [ + '* []' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should merge a paragraph into following list containing an inline widget', () => { + runTest( { + input: [ + '[]', + '* a' + ], + expected: [ + '* []a {id:001}' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should merge an empty list item into following list item containing an inline widget', () => { + runTest( { + input: [ + '* []', + '* a' + ], + expected: [ + '* []a {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove an inline widget in a list item block containing other content (before)', () => { + runTest( { + input: [ + '* a[]' + ], + expected: [ + '* a[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove an inline widget in a list item block containing other content (after)', () => { + runTest( { + input: [ + '* []a' + ], + expected: [ + '* []a' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove an inline widget in a middle list item block', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should remove an inline widget in a nested list item block', () => { + runTest( { + input: [ + '* a', + ' * []', + ' b' + ], + expected: [ + '* a', + ' * []', + ' b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + } ); + } ); } ); // @param {Iterable.} input @@ -4962,6 +5796,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { // @param {Object.} executedCommands Numbers of command executions. // @param {Array.} changedBlocks Indexes of changed blocks. function runTest( { input, expected, eventStopped, executedCommands = {}, changedBlocks = [] } ) { + // console.log( 'in', modelList( input ) ); setModelData( model, modelList( input ) ); view.document.fire( eventInfo, domEventData ); From 1656a9f2ef6282f8acdd70c97be74846ba12c7cb Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 1 Feb 2022 14:46:30 +0100 Subject: [PATCH 29/44] Added missing tests for document list integration with backspace/delete. Code refactoring. --- .../src/documentlist/documentlistediting.js | 14 +- .../tests/documentlist/integrations/delete.js | 1096 ++++++++++++++--- 2 files changed, 934 insertions(+), 176 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 3628f9a88d3..fba4e2aed5e 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -159,6 +159,8 @@ export default class DocumentListEditing extends Plugin { */ _setupDeleteIntegration() { const editor = this.editor; + const mergeBackwardCommand = editor.commands.get( 'mergeListItemBackward' ); + const mergeForwardCommand = editor.commands.get( 'mergeListItemForward' ); this.listenTo( editor.editing.view.document, 'delete', ( evt, data ) => { const selection = editor.model.document.selection; @@ -189,13 +191,11 @@ export default class DocumentListEditing extends Plugin { } // Merge block with previous one (on the block level or on the content level). else { - const mergeListItemCommand = editor.commands.get( 'mergeListItemBackward' ); - - if ( !mergeListItemCommand.isEnabled ) { + if ( !mergeBackwardCommand.isEnabled ) { return; } - mergeListItemCommand.execute(); + mergeBackwardCommand.execute(); } data.preventDefault(); @@ -208,13 +208,11 @@ export default class DocumentListEditing extends Plugin { return; } - const mergeListItemCommand = editor.commands.get( 'mergeListItemForward' ); - - if ( !mergeListItemCommand.isEnabled ) { + if ( !mergeForwardCommand.isEnabled ) { return; } - mergeListItemCommand.execute(); + mergeForwardCommand.execute(); data.preventDefault(); evt.stop(); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index b215dbe102f..0e48b81a4c0 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -146,6 +146,28 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); describe( 'single block list item', () => { + it( 'should not engage when the selection is in the middle of a text', () => { + runTest( { + input: [ + '* a[]b' + ], + expected: [ + '* []b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + describe( 'collapsed selection at the beginning of a list item', () => { describe( 'item before is empty', () => { it( 'should remove list when in empty only element of a list', () => { @@ -1131,6 +1153,31 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { describe( 'multi-block list item', () => { describe( 'collapsed selection at the beginning of a list item', () => { + describe( 'no item before', () => { + it( 'should split the list item and then outdent if selection anchored in a first empty of many blocks', () => { + runTest( { + input: [ + '* []', + ' a', + ' b' + ], + expected: [ + '[]', + '* a {id:a00}', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 1, + splitAfter: 1, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [ 1, 2, 0 ] + } ); + } ); + } ); + describe( 'item before is empty', () => { it( 'should merge with previous list item and keep blocks intact', () => { runTest( { @@ -2094,6 +2141,36 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); describe( 'selection outside list', () => { + it( 'should not engage for a
  • that is not a document list item', () => { + model.schema.register( 'thirdPartyListItem', { inheritAllFrom: '$block' } ); + + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'thirdPartyListItem', + view: ( modelItem, { writer } ) => writer.createContainerElement( 'li' ) + } ); + + runTest( { + input: [ + 'a', + '[]b' + ], + expected: [ + 'a[]b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + describe( 'collapsed selection', () => { it( 'no list editing commands should be executed outside list (empty paragraph)', () => { runTest( { @@ -2996,10 +3073,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* a', ' []' ], - eventStopped: { - preventDefault: true, - stop: true - }, + eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, @@ -3022,10 +3096,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' []', ' b' ], - eventStopped: { - preventDefault: true, - stop: true - }, + eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, @@ -3048,10 +3119,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' []', ' * b {id:002}' ], - eventStopped: { - preventDefault: true, - stop: true - }, + eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, @@ -3072,10 +3140,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { '* a', ' * []' ], - eventStopped: { - preventDefault: true, - stop: true - }, + eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, @@ -3098,10 +3163,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ' * []', ' b' ], - eventStopped: { - preventDefault: true, - stop: true - }, + eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, @@ -3487,6 +3549,28 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); describe( 'single block list item', () => { + it( 'should not engage when the selection is in the middle of a text', () => { + runTest( { + input: [ + '* a[]b' + ], + expected: [ + '* a[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + describe( 'collapsed selection at the end of a list item', () => { describe( 'item after is empty', () => { it( 'should not remove list when in empty only element of a list', () => { @@ -4225,7 +4309,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it.skip( 'should merge following complex list item with current one', () => { + it( 'should merge following complex list item with current one', () => { runTest( { input: [ '* ', @@ -4244,7 +4328,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ], expected: [ '* ', - ' []b', + '* []b {id:002}', ' c', ' * d {id:d}', ' e', @@ -4263,7 +4347,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { mergeBackward: 0, mergeForward: 1 }, - changedBlocks: [ 1 ] + changedBlocks: [ 1, 2, 11 ] } ); } ); @@ -5168,105 +5252,50 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - describe( 'around widgets', () => { - describe( 'block widgets', () => { - it( 'should delete a paragraph and select a block widget in a list that follows it', () => { - runTest( { - input: [ - '[]', - '* ' - ], - expected: [ - '* [] {id:001}' - ], - eventStopped: true, - executedCommands: { - outdent: 0, - splitAfter: 0, - mergeBackward: 0, - mergeForward: 0 - }, - changedBlocks: [] - } ); - } ); + describe( 'selection outside list', () => { + it( 'should not engage for a
  • that is not a document list item', () => { + model.schema.register( 'thirdPartyListItem', { inheritAllFrom: '$block' } ); - it( 'should select a block widget in a list that follows a non-empty paragraph', () => { - runTest( { - input: [ - 'foo[]', - '* ' - ], - expected: [ - 'foo', - '* []' - ], - eventStopped: true, - executedCommands: { - outdent: 0, - splitAfter: 0, - mergeBackward: 0, - mergeForward: 0 - }, - changedBlocks: [] - } ); + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'thirdPartyListItem', + view: ( modelItem, { writer } ) => writer.createContainerElement( 'li' ) } ); - it( 'should delete a paragraph and select a block widget (1st block) in a list that follows it', () => { - runTest( { - input: [ - '[]', - '* ', - ' a' - ], - expected: [ - '* [] {id:001}', - ' a' - ], - eventStopped: true, - executedCommands: { - outdent: 0, - splitAfter: 0, - mergeBackward: 0, - mergeForward: 0 - }, - changedBlocks: [] - } ); + runTest( { + input: [ + 'a[]', + 'b' + ], + expected: [ + 'a[]b' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] } ); + } ); - it( 'should merge an item into the next one despite a block widget following it', () => { + describe( 'collapsed selection', () => { + it( 'no list editing commands should be executed outside list (empty paragraph)', () => { runTest( { input: [ - '* []', - '* ', - ' a' + '[]' ], expected: [ - '* [] {id:001}', - ' a' + '[]' ], - eventStopped: true, - executedCommands: { - outdent: 0, - splitAfter: 0, - mergeBackward: 0, - mergeForward: 0 + eventStopped: { + preventDefault: true, + stop: false }, - changedBlocks: [] - } ); - } ); - - it( 'should merge an item into the next one despite a block widget following it at a deeper level', () => { - runTest( { - input: [ - '* a', - '* []', - ' * ' - ], - expected: [ - '* a', - ' * [] {id:002}' - ], - eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, @@ -5277,20 +5306,18 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete an item block and select a block widget that follows it', () => { + it( 'no list editing commands should be executed outside list (selection at the beginning of text)', () => { runTest( { input: [ - '* a', - ' []', - ' ', - ' b' + '[]text' ], expected: [ - '* a', - ' []', - ' b' + '[]ext' ], - eventStopped: true, + eventStopped: { + preventDefault: true, + stop: false + }, executedCommands: { outdent: 0, splitAfter: 0, @@ -5301,122 +5328,855 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the list item block that follows it', () => { + it( 'no list editing commands should be executed outside list (selection at the end of text)', () => { runTest( { input: [ - '* a', - ' []' + 'text[]' ], expected: [ - '* a', - ' []' + 'text[]' ], eventStopped: { preventDefault: true, - stop: true + stop: false }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 1 + mergeForward: 0 }, changedBlocks: [] } ); } ); - it( 'should delete a block widget and move the selection to the block that follows it (multiple blocks)', () => { + it( 'no list editing commands should be executed outside list (selection in the middle of text)', () => { runTest( { input: [ - '* a', - ' []', - ' b' + 'te[]xt' ], expected: [ - '* a', - ' []', - ' b' + 'te[]t' ], eventStopped: { preventDefault: true, - stop: true + stop: false }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 1 + mergeForward: 0 }, changedBlocks: [] } ); } ); - it( 'should delete a block widget and move the selection to the block that follows it (nested item follows)', () => { + it( 'no list editing commands should be executed next to a list', () => { runTest( { input: [ - '* a', - ' []', - ' * b' + '* 1', + '[]2' ], expected: [ - '* a', - ' []', - ' * b {id:002}' + '* 1', + '[]' ], eventStopped: { preventDefault: true, - stop: true + stop: false }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 1 + mergeForward: 0 }, changedBlocks: [] } ); } ); - it( 'should delete a block widget and move the selection down to the (shallower) block that follows it', () => { + it( 'empty list should be deleted', () => { runTest( { input: [ - '* a', - ' * []' + '* 1', + '2[]', + '* ' ], expected: [ - '* a', - ' * []' + '* 1', + '2[]' ], eventStopped: { preventDefault: true, - stop: true + stop: false }, executedCommands: { outdent: 0, splitAfter: 0, mergeBackward: 0, - mergeForward: 1 + mergeForward: 0 }, changedBlocks: [] } ); } ); + } ); - it( 'should delete a block widget and move the selection down to the block that follows it (multiple blocks)', () => { - runTest( { - input: [ - '* a', - ' * []', - ' b' - ], - expected: [ - '* a', - ' * []', - ' b' - ], - eventStopped: { - preventDefault: true, - stop: true - }, + describe( 'non-collapsed selection', () => { + describe( 'outside list', () => { + it( 'no list editing commands should be executed', () => { + runTest( { + input: [ + 't[ex]t' + ], + expected: [ + 't[]t' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'no list editing commands should be executed when outside list when next to a list', () => { + runTest( { + input: [ + 't[ex]t', + '* 1' + ], + expected: [ + 't[]t', + '* 1' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + } ); + + describe( 'only start in a list', () => { + it( 'no list editing commands should be executed when doing delete', () => { + runTest( { + input: [ + '* te[xt', + 'aa]' + ], + expected: [ + '* te[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'no list editing commands should be executed when doing delete (multi-block list)', () => { + runTest( { + input: [ + '* te[xt1', + ' text2', + ' * text3', + 'text4]' + ], + expected: [ + '* te[]' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete everything till end of selection and merge remaining text', () => { + runTest( { + input: [ + '* text1', + ' tex[t2', + ' * text3', + 'tex]t4' + ], + expected: [ + '* text1', + ' tex[]t4' + ], + eventStopped: { + preventDefault: true, + stop: false + }, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + } ); + + describe( 'only end in a list', () => { + it( 'should delete everything till end of selection', () => { + runTest( { + input: [ + '[', + '* te]xt' + ], + expected: [ + '* []xt {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should delete everything till the end of selection and adjust remaining block to item list', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' c' + ], + expected: [ + 'a[]b', + '* c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should delete everything till the end of selection and adjust remaining item list indentation', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' * c' + ], + expected: [ + 'a[]b', + '* c {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + // Note: Technically speaking "c" should also be included but wasn't; was fixed by model post-fixer. + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should delete selection and adjust remaining item list indentation (multi-block)', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' * c', + ' d' + ], + expected: [ + 'a[]b', + '* c {id:002}', + ' d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + // Note: Technically speaking "c" and "d" should also be included but weren't; fixed by model post-fixer. + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove selection and adjust remaining list', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' * c', + ' d' + ], + expected: [ + 'a[]b', + '* c {id:002}', + '* d {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + // Note: Technically speaking "c" and "d" should also be included but weren't; fixed by model post-fixer. + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove selection and adjust remaining list (multi-block)', () => { + runTest( { + input: [ + 'a[', + '* b', + ' * c', + ' d]d', + ' * e', + ' f' + ], + expected: [ + 'a[]d', + '* e {id:004}', + ' f' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1, 2 ] + } ); + } ); + } ); + + describe( 'spanning multiple lists', () => { + it( 'should merge lists into one with one list item', () => { + runTest( { + input: [ + '* a[a', + 'b', + '* c]c' + ], + expected: [ + '* a[]c' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge lists into one with two blocks', () => { + runTest( { + input: [ + '* a', + ' b[b', + 'c', + '* d]d' + ], + expected: [ + '* a', + ' b[]d' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge two lists into one with two list items', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d]', + '* e' + ], + expected: [ + '* a[]', + '* e {id:003}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge two lists into one with two list items (multiple blocks)', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d]', + ' e', + '* f' + ], + expected: [ + '* a[]', + ' e', + '* f {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should merge two lists into one with two list items and adjust indentation', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ], + expected: [ + '* a[]e', + ' * f {id:004}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0, 1, 2 ] + } ); + } ); + + it( 'should merge two lists into one with deeper indendation', () => { + runTest( { + input: [ + '* a', + ' * b[', + 'c', + '* d', + ' * e', + ' * f]f', + ' * g' + ], + expected: [ + '* a', + ' * b[]f', + ' * g {id:006}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1, 2 ] + } ); + } ); + + it( 'should merge two lists into one with deeper indentation (multiple blocks)', () => { + runTest( { + input: [ + '* a', + ' * b[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ], + expected: [ + '* a', + ' * b[]e', + ' * f {id:005}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge two lists into one and keep items after selection', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d', + ' * e]e', + '* f', + ' g' + ], + expected: [ + '* a[]e', + '* f {id:004}', + ' g' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge lists of different types to a single list and keep item lists types', () => { + runTest( { + input: [ + '* a', + '* b[b', + 'c', + '# d]d', + '# d' + ], + expected: [ + '* a', + '* b[]d', + '# d {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge lists of mixed types to a single list and keep item lists types', () => { + runTest( { + input: [ + '* a', + '# b[b', + 'c', + '# d]d', + ' * f' + ], + expected: [ + '* a', + '# b[]d', + ' * f {id:004}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [ 1 ] + } ); + } ); + } ); + } ); + } ); + + describe( 'around widgets', () => { + describe( 'block widgets', () => { + it( 'should delete a paragraph and select a block widget in a list that follows it', () => { + runTest( { + input: [ + '[]', + '* ' + ], + expected: [ + '* [] {id:001}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should select a block widget in a list that follows a non-empty paragraph', () => { + runTest( { + input: [ + 'foo[]', + '* ' + ], + expected: [ + 'foo', + '* []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a paragraph and select a block widget (1st block) in a list that follows it', () => { + runTest( { + input: [ + '[]', + '* ', + ' a' + ], + expected: [ + '* [] {id:001}', + ' a' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should merge an item into the next one despite a block widget following it', () => { + runTest( { + input: [ + '* []', + '* ', + ' a' + ], + expected: [ + '* [] {id:001}', + ' a' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should merge an item into the next one despite a block widget following it at a deeper level', () => { + runTest( { + input: [ + '* a', + '* []', + ' * ' + ], + expected: [ + '* a', + ' * [] {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete an item block and select a block widget that follows it', () => { + runTest( { + input: [ + '* a', + ' []', + ' ', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection to the list item block that follows it', () => { + runTest( { + input: [ + '* a', + ' []' + ], + expected: [ + '* a', + ' []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection to the block that follows it (multiple blocks)', () => { + runTest( { + input: [ + '* a', + ' []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection to the block that follows it (nested item follows)', () => { + runTest( { + input: [ + '* a', + ' []', + ' * b' + ], + expected: [ + '* a', + ' []', + ' * b {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection down to the (shallower) block that follows it', () => { + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a', + ' * []' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 1 + }, + changedBlocks: [] + } ); + } ); + + it( 'should delete a block widget and move the selection down to the block that follows it (multiple blocks)', () => { + runTest( { + input: [ + '* a', + ' * []', + ' b' + ], + expected: [ + '* a', + ' * []', + ' b' + ], + eventStopped: true, executedCommands: { outdent: 0, splitAfter: 0, From 519a807c72cc5f0cafe7926e2bf71a2f7f67d170 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 1 Feb 2022 18:00:37 +0100 Subject: [PATCH 30/44] Code refactoring. --- .../src/documentlist/documentlistediting.js | 51 +++++- .../documentlist/documentlistmergecommand.js | 150 ++++++------------ .../tests/documentlist/integrations/delete.js | 50 ++++-- 3 files changed, 129 insertions(+), 122 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index fba4e2aed5e..f9e08ae686b 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -14,7 +14,7 @@ import { CKEditorError } from 'ckeditor5/src/utils'; import DocumentListIndentCommand from './documentlistindentcommand'; import DocumentListCommand from './documentlistcommand'; -import DocumentListMergeCommand from './documentlistmergecommand'; +import DocumentListMergeCommand, { getSelectedBlockObject } from './documentlistmergecommand'; import DocumentListSplitCommand from './documentlistsplitcommand'; import { listItemDowncastConverter, @@ -32,7 +32,8 @@ import { import { getAllListItemBlocks, isFirstBlockOfListItem, - isLastBlockOfListItem + isLastBlockOfListItem, + isSingleListItem } from './utils/model'; import ListWalker, { iterateSiblingListBlocks } from './utils/listwalker'; @@ -166,9 +167,10 @@ export default class DocumentListEditing extends Plugin { const selection = editor.model.document.selection; editor.model.change( () => { - if ( selection.isCollapsed && data.direction == 'backward' ) { - const firstPosition = selection.getFirstPosition(); + const firstPosition = selection.getFirstPosition(); + const lastPosition = selection.getLastPosition(); + if ( selection.isCollapsed && data.direction == 'backward' ) { if ( !firstPosition.isAtStart ) { return; } @@ -195,7 +197,9 @@ export default class DocumentListEditing extends Plugin { return; } - mergeBackwardCommand.execute(); + mergeBackwardCommand.execute( { + shouldMergeOnBlocksContentLevel: shouldMergeOnBlocksContentLevel( editor.model, 'backward' ) + } ); } data.preventDefault(); @@ -208,11 +212,19 @@ export default class DocumentListEditing extends Plugin { return; } + // If deleting within a single block of a list item, there's no need to merge anything. + // The default delete should be executed instead. + if ( !selection.isCollapsed && firstPosition.parent === lastPosition.parent ) { + return; + } + if ( !mergeForwardCommand.isEnabled ) { return; } - mergeForwardCommand.execute(); + mergeForwardCommand.execute( { + shouldMergeOnBlocksContentLevel: shouldMergeOnBlocksContentLevel( editor.model, 'forward' ) + } ); data.preventDefault(); evt.stop(); @@ -454,3 +466,30 @@ function createModelIndentPasteFixer( model ) { } ); }; } + +// TODO +function shouldMergeOnBlocksContentLevel( model, direction ) { + const selection = model.document.selection; + + if ( !selection.isCollapsed ) { + return !getSelectedBlockObject( model ); + } + + if ( direction === 'forward' ) { + return true; + } + + const firstPosition = selection.getFirstPosition(); + const positionParent = firstPosition.parent; + const previousSibling = positionParent.previousSibling; + + if ( model.schema.isObject( previousSibling ) ) { + return false; + } + + if ( previousSibling.isEmpty ) { + return true; + } + + return isSingleListItem( [ positionParent, previousSibling ] ); +} diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 0be3473736b..583bd6912f3 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -57,13 +57,12 @@ export default class DocumentListMergeCommand extends Command { * @fires execute * @fires afterExecute */ - execute() { + execute( { shouldMergeOnBlocksContentLevel = false } = {} ) { const model = this.editor.model; const selection = model.document.selection; const changedBlocks = []; model.change( writer => { - const shouldMergeOnBlocksContentLevel = this._shouldMergeOnBlocksContentLevel(); const { firstElement, lastElement } = this._getMergeSubjectElements( selection, shouldMergeOnBlocksContentLevel ); const firstIndent = firstElement.getAttribute( 'listIndent' ) || 0; @@ -82,48 +81,30 @@ export default class DocumentListMergeCommand extends Command { } if ( shouldMergeOnBlocksContentLevel ) { - const selectedElement = selection.getSelectedElement(); - - if ( selectedElement ) { - const listItemId = selectedElement.getAttribute( 'listItemId' ); - const listType = selectedElement.getAttribute( 'listType' ); - const listIndent = selectedElement.getAttribute( 'listIndent' ); - - model.deleteContent( selection, { - doNotResetEntireContent: false, - doNotAutoparagraph: false - } ); - - const lastElementAfterDelete = selection.getLastPosition().parent; - - writer.setAttributes( { listItemId, listType, listIndent }, lastElementAfterDelete ); - } else { - let sel = selection; - - if ( selection.isCollapsed ) { - sel = writer.createSelection( writer.createRange( - writer.createPositionAt( firstElement, 'end' ), - writer.createPositionAt( lastElement, 0 ) - ) ); - } + let sel = selection; + + if ( selection.isCollapsed ) { + // TODO what if one of blocks is an object (for example a table or block image)? + sel = writer.createSelection( writer.createRange( + writer.createPositionAt( firstElement, 'end' ), + writer.createPositionAt( lastElement, 0 ) + ) ); + } - // Delete selected content. Replace entire content only for non-collapsed selection. - model.deleteContent( sel, { - doNotResetEntireContent: selection.isCollapsed - } ); + // Delete selected content. Replace entire content only for non-collapsed selection. + model.deleteContent( sel, { doNotResetEntireContent: selection.isCollapsed } ); - // Get the last "touched" element after deleteContent call (can't use the lastElement because - // it could get merged into the firstElement while deleting content). - const lastElementAfterDelete = sel.getLastPosition().parent; + // Get the last "touched" element after deleteContent call (can't use the lastElement because + // it could get merged into the firstElement while deleting content). + const lastElementAfterDelete = sel.getLastPosition().parent; - // Check if the element after it was in the same list item and adjust it if needed. - const nextSibling = lastElementAfterDelete.nextSibling; + // Check if the element after it was in the same list item and adjust it if needed. + const nextSibling = lastElementAfterDelete.nextSibling; - changedBlocks.push( lastElementAfterDelete ); + changedBlocks.push( lastElementAfterDelete ); - if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { - changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); - } + if ( nextSibling && nextSibling !== lastElement && nextSibling.getAttribute( 'listItemId' ) == lastElementId ) { + changedBlocks.push( ...mergeListItemBefore( nextSibling, lastElementAfterDelete, writer ) ); } } else { changedBlocks.push( ...mergeListItemBefore( lastElement, firstElement, writer ) ); @@ -161,10 +142,10 @@ export default class DocumentListMergeCommand extends Command { _checkEnabled() { const model = this.editor.model; const selection = model.document.selection; + const selectedBlockObject = getSelectedBlockObject( model ); - if ( selection.isCollapsed ) { - const firstPosition = selection.getFirstPosition(); - const positionParent = firstPosition.parent; + if ( selection.isCollapsed || selectedBlockObject ) { + const positionParent = selectedBlockObject || selection.getFirstPosition().parent; if ( !positionParent.hasAttribute( 'listItemId' ) ) { return false; @@ -178,67 +159,21 @@ export default class DocumentListMergeCommand extends Command { return false; } - // [] - // * - // - // OR - // - // * [] - // * - if ( model.schema.isObject( siblingNode ) && this._direction == 'forward' ) { - return false; - } - if ( isSingleListItem( [ positionParent, siblingNode ] ) ) { return false; } } else { - const selectedElement = selection.getSelectedElement(); + const lastPosition = selection.getLastPosition(); + const positionParent = lastPosition.parent; - if ( selectedElement ) { - if ( !selectedElement.hasAttribute( 'listItemId' ) ) { - return false; - } - } else { - const lastPosition = selection.getLastPosition(); - const positionParent = lastPosition.parent; - - if ( !positionParent.hasAttribute( 'listItemId' ) ) { - return false; - } + if ( !positionParent.hasAttribute( 'listItemId' ) ) { + return false; } } return true; } - /** - * - * @returns TODO - */ - _shouldMergeOnBlocksContentLevel() { - const model = this.editor.model; - const selection = model.document.selection; - - if ( !selection.isCollapsed || this._direction === 'forward' ) { - return true; - } - - const firstPosition = selection.getFirstPosition(); - const positionParent = firstPosition.parent; - const previousSibling = positionParent.previousSibling; - - if ( model.schema.isObject( previousSibling ) ) { - return false; - } - - if ( previousSibling.isEmpty ) { - return true; - } - - return isSingleListItem( [ positionParent, previousSibling ] ); - } - /** * TODO * @@ -247,10 +182,12 @@ export default class DocumentListMergeCommand extends Command { * @returns */ _getMergeSubjectElements( selection, shouldMergeOnBlocksContentLevel ) { + const model = this.editor.model; + const selectedBlockObject = getSelectedBlockObject( model ); let firstElement, lastElement; - if ( selection.isCollapsed ) { - const positionParent = selection.getFirstPosition().parent; + if ( selection.isCollapsed || selectedBlockObject ) { + const positionParent = selectedBlockObject || selection.getFirstPosition().parent; const isFirstBlock = isFirstBlockOfListItem( positionParent ); if ( this._direction == 'backward' ) { @@ -275,16 +212,25 @@ export default class DocumentListMergeCommand extends Command { lastElement = positionParent.nextSibling; } } else { - const selectedElement = selection.getSelectedElement(); - - if ( selectedElement ) { - firstElement = lastElement = selectedElement; - } else { - firstElement = selection.getFirstPosition().parent; - lastElement = selection.getLastPosition().parent; - } + firstElement = selection.getFirstPosition().parent; + lastElement = selection.getLastPosition().parent; } return { firstElement, lastElement }; } } + +// TODO +export function getSelectedBlockObject( model ) { + const selectedElement = model.document.selection.getSelectedElement(); + + if ( !selectedElement ) { + return null; + } + + if ( model.schema.isObject( selectedElement ) && model.schema.isBlock( selectedElement ) ) { + return selectedElement; + } + + return null; +} diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 0e48b81a4c0..eaa0ea6d3a3 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -3063,7 +3063,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the list item block that precedes it', () => { + it.skip( 'should delete a block widget and move the selection to the list item block that precedes it', () => { runTest( { input: [ '* a', @@ -3084,7 +3084,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the block that precedes it (multiple blocks)', () => { + it.skip( 'should delete a block widget and move the selection to the block that precedes it (multiple blocks)', () => { runTest( { input: [ '* a', @@ -3107,7 +3107,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the block that precedes it (nested item follows)', () => { + it.skip( 'should delete a block widget and move the selection to the block that precedes it (nested item follows)', () => { runTest( { input: [ '* a', @@ -3130,7 +3130,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection down to the (shallower) block that precedes it', () => { + it.skip( 'should delete a block widget and move the selection down to the (shallower) block that precedes it', () => { runTest( { input: [ '* a', @@ -3151,7 +3151,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection down to the block that precedes it (multiple blocks)', () => { + it.skip( 'should delete a block widget and move the selection down to the block that precedes it (multiple blocks)', () => { runTest( { input: [ '* a', @@ -3347,7 +3347,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should remove a block widget surrounded by block containing inline images at boundaries', () => { + it.skip( 'should remove a block widget surrounded by block containing inline images at boundaries', () => { runTest( { input: [ '* a', @@ -6008,7 +6008,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should merge an item into the next one despite a block widget following it', () => { + it.skip( 'should merge an item into the next one despite a block widget following it', () => { runTest( { input: [ '* []', @@ -6030,7 +6030,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should merge an item into the next one despite a block widget following it at a deeper level', () => { + it.skip( 'should merge an item into the next one despite a block widget following it at a deeper level', () => { runTest( { input: [ '* a', @@ -6052,6 +6052,28 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); + it.skip( 'should merge an item into the next one despite a block widget following it at an even deeper level', () => { + runTest( { + input: [ + '* a', + ' * []', + ' * ' + ], + expected: [ + '* a', + ' * [] {id:002}' + ], + eventStopped: true, + executedCommands: { + outdent: 0, + splitAfter: 0, + mergeBackward: 0, + mergeForward: 0 + }, + changedBlocks: [] + } ); + } ); + it( 'should delete an item block and select a block widget that follows it', () => { runTest( { input: [ @@ -6076,7 +6098,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the list item block that follows it', () => { + it.skip( 'should delete a block widget and move the selection to the list item block that follows it', () => { runTest( { input: [ '* a', @@ -6097,7 +6119,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the block that follows it (multiple blocks)', () => { + it.skip( 'should delete a block widget and move the selection to the block that follows it (multiple blocks)', () => { runTest( { input: [ '* a', @@ -6120,7 +6142,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection to the block that follows it (nested item follows)', () => { + it.skip( 'should delete a block widget and move the selection to the block that follows it (nested item follows)', () => { runTest( { input: [ '* a', @@ -6143,7 +6165,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection down to the (shallower) block that follows it', () => { + it.skip( 'should delete a block widget and move the selection down to the (shallower) block that follows it', () => { runTest( { input: [ '* a', @@ -6164,7 +6186,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should delete a block widget and move the selection down to the block that follows it (multiple blocks)', () => { + it.skip( 'should delete a block widget and move the selection down to the block that follows it (multiple blocks)', () => { runTest( { input: [ '* a', @@ -6360,7 +6382,7 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { } ); } ); - it( 'should remove a block widget surrounded by block containing inline images at boundaries', () => { + it.skip( 'should remove a block widget surrounded by block containing inline images at boundaries', () => { runTest( { input: [ '* a', From ac426c1d5294fa537f70be962061e96dc86431ea Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Tue, 1 Feb 2022 18:12:09 +0100 Subject: [PATCH 31/44] Code refactoring in tests --- packages/ckeditor5-list/tests/documentlist/_utils/utils.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js index a76ba58298c..1aea32dbcba 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js @@ -26,7 +26,7 @@ export function prepareTest( model, input ) { const selection = parsedResult.selection; // Ensure no undo step is generated. - model.enqueueChange( 'transparent', writer => { + model.enqueueChange( { isUndoable: false }, writer => { // Replace existing model in document by new one. writer.remove( writer.createRangeIn( modelRoot ) ); writer.insert( modelDocumentFragment, modelRoot ); From 8e511a0b8c850b224d08ac05cba21538cbf3d36f Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 11:57:51 +0100 Subject: [PATCH 32/44] Added tests for DocumentListMerge command. Docs. --- .../src/documentlist/documentlistediting.js | 15 +- .../documentlist/documentlistmergecommand.js | 41 +- .../documentlist/documentlistmergecommand.js | 4373 ++++++++++------- .../tests/documentlist/integrations/delete.js | 1 - .../tests/manual/listmocking.js | 1 + 5 files changed, 2699 insertions(+), 1732 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 27c9ad10594..ed87cd63e29 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -168,7 +168,6 @@ export default class DocumentListEditing extends Plugin { editor.model.change( () => { const firstPosition = selection.getFirstPosition(); - const lastPosition = selection.getLastPosition(); if ( selection.isCollapsed && data.direction == 'backward' ) { if ( !firstPosition.isAtStart ) { @@ -212,12 +211,6 @@ export default class DocumentListEditing extends Plugin { return; } - // If deleting within a single block of a list item, there's no need to merge anything. - // The default delete should be executed instead. - if ( !selection.isCollapsed && firstPosition.parent === lastPosition.parent ) { - return; - } - if ( !mergeForwardCommand.isEnabled ) { return; } @@ -467,7 +460,13 @@ function createModelIndentPasteFixer( model ) { }; } -// TODO +// Decided whether the merge should be accompanied by the model's `deleteContent()`, for instance to get rid of the inline +// content in the selection or take advantage of the heuristics in `deleteContent()` that helps convert lists into paragraphs +// in certain cases. +// +// @param {module:engine/model/model~Model} model +// @param {'backward'|'forward'} direction +// @returns {Boolean} function shouldMergeOnBlocksContentLevel( model, direction ) { const selection = model.document.selection; diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 583bd6912f3..646ba1f9895 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -19,8 +19,7 @@ import { import ListWalker from './utils/listwalker'; /** - * TODO - * The document list indent command. It is used by the {@link module:list/documentlist~DocumentList list feature}. + * The document list merge command. It is used by the {@link module:list/documentlist~DocumentList list feature}. * * @extends module:core/command~Command */ @@ -52,10 +51,14 @@ export default class DocumentListMergeCommand extends Command { } /** - * TODO + * Merges list blocks together (depending on the {@link #constructor}'s `direction` parameter). * * @fires execute * @fires afterExecute + * @param {Object} [options] Command options. + * @param {String|Boolean} [options.shouldMergeOnBlocksContentLevel=false] When set `true`, merging will be performed together + * with {@link module:engine/model/model~Model#deleteContent} to get rid of the inline content in the selection or take advantage + * of the heuristics in `deleteContent()` that helps convert lists into paragraphs in certain cases. */ execute( { shouldMergeOnBlocksContentLevel = false } = {} ) { const model = this.editor.model; @@ -115,7 +118,7 @@ export default class DocumentListMergeCommand extends Command { } /** - * TODO + * Fires the `afterExecute` event. * * @private * @param {Array.} changedBlocks The changed list elements. @@ -124,7 +127,7 @@ export default class DocumentListMergeCommand extends Command { /** * Event fired by the {@link #execute} method. * - * It allows to execute an action after executing the {@link ~DocumentListIndentCommand#execute} method, + * It allows to execute an action after executing the {@link ~DocumentListMergeCommand#execute} method, * for example adjusting attributes of changed list items. * * @protected @@ -164,9 +167,15 @@ export default class DocumentListMergeCommand extends Command { } } else { const lastPosition = selection.getLastPosition(); - const positionParent = lastPosition.parent; + const firstPosition = selection.getFirstPosition(); - if ( !positionParent.hasAttribute( 'listItemId' ) ) { + // If deleting within a single block of a list item, there's no need to merge anything. + // The default delete should be executed instead. + if ( lastPosition.parent === firstPosition.parent ) { + return false; + } + + if ( !lastPosition.parent.hasAttribute( 'listItemId' ) ) { return false; } } @@ -175,11 +184,15 @@ export default class DocumentListMergeCommand extends Command { } /** - * TODO + * Returns the boundary elements the merge should be executed for. These are not necessarily selection's first + * and last position parents but sometimes sibling or even further blocks depending on the context. * - * @param {*} selection - * @param {*} shouldMergeOnBlocksContentLevel - * @returns + * @param {module:engine/model/selection~Selection} selection The selection the merge is executed for. + * @param {Boolean} shouldMergeOnBlocksContentLevel When `true`, merge is performed together with + * {@link module:engine/model/model~Model#deleteContent} to remove the inline content within the selection. + * @returns {Object.} elements + * @returns {module:engine/model/element~Element} elements.firstElement + * @returns {module:engine/model/element~Element} elements.lastElement */ _getMergeSubjectElements( selection, shouldMergeOnBlocksContentLevel ) { const model = this.editor.model; @@ -220,7 +233,11 @@ export default class DocumentListMergeCommand extends Command { } } -// TODO +// Returns a selected block object. If a selected object is inline or when there is no selected +// object, `null` is returned. +// +// @param {module:engine/model/model~Model} model +// @returns {module:engine/model/element~Element|null} export function getSelectedBlockObject( model ) { const selectedElement = model.document.selection.getSelectedElement(); diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js index 85917025c2f..ea9ebf66adc 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js @@ -8,12 +8,14 @@ import DocumentListMergeCommand from '../../src/documentlist/documentlistmergeco import Editor from '@ckeditor/ckeditor5-core/src/editor/editor'; import Model from '@ckeditor/ckeditor5-engine/src/model/model'; +import { toWidget } from '@ckeditor/ckeditor5-widget/src/utils'; import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; import { setData, getData } from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; -describe.skip( 'DocumentListMergeCommand', () => { +describe( 'DocumentListMergeCommand', () => { let editor, model, doc, command; + let blocksChangedByCommands = []; testUtils.createSinonSandbox(); @@ -28,1597 +30,2200 @@ describe.skip( 'DocumentListMergeCommand', () => { model.schema.register( 'paragraph', { inheritAllFrom: '$block' } ); model.schema.register( 'blockQuote', { inheritAllFrom: '$container' } ); model.schema.extend( '$container', { allowAttributes: [ 'listType', 'listIndent', 'listItemId' ] } ); - command = new DocumentListMergeCommand( editor, 'backward' ); + model.schema.register( 'blockWidget', { + isObject: true, + isBlock: true, + allowIn: '$root', + allowAttributesOf: '$container' + } ); + + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'blockWidget', + view: ( modelItem, { writer } ) => { + return toWidget( writer.createContainerElement( 'blockwidget', { class: 'block-widget' } ), writer ); + } + } ); + + editor.model.schema.register( 'inlineWidget', { + isObject: true, + isInline: true, + allowWhere: '$text', + allowAttributesOf: '$text' + } ); + + // The view element has no children. + editor.conversion.for( 'downcast' ).elementToElement( { + model: 'inlineWidget', + view: ( modelItem, { writer } ) => toWidget( + writer.createContainerElement( 'inlinewidget', { class: 'inline-widget' } ), writer, { label: 'inline widget' } + ) + } ); } ); afterEach( () => { command.destroy(); } ); - // TODO add cases for forward delete - describe( 'isEnabled', () => { - describe( 'enabled', () => { - describe( 'when collapsed selection', () => { - describe( 'selection at the start of a block (backward delete)', () => { - // TODO: sepreate to 3 seperate its - it( 'if preceded by other list item of same indentation', () => { - setData( model, modelList( [ - '* a', - '* []b', - '* c', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - - setData( model, modelList( [ - '* a', - '* b', - '* []c', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - - setData( model, modelList( [ - '* a', - '* b', - '* c', - '* []d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is at the beginning of list item that is preceded by other list item of lower indentation', () => { - setData( model, modelList( [ - '* a', - '* b', - ' * []c', - ' * d', - '* e', - '* f' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is at the beginning of list item that is preceded by other list item of higher indentation', () => { - setData( model, modelList( [ - '* a', - '* b', - ' * c', - ' * d', - ' * []e', - '* f', - '* g' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is at the beginning of the first block of list item', () => { - setData( model, modelList( [ - '* a', - '* []b', - ' c', - ' d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - // TODO: in this case command should be disabled and backspace default behaviour should handle it - it( 'if selection is at the beginning of non-initial block of list item', () => { - setData( model, modelList( [ - '* a', - '* b', - ' []c', - ' d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - // TODO: in this case command should be disabled and backspace default behaviour should handle it - it( 'if selection is at the beginning of the last block of list item', () => { - setData( model, modelList( [ - '* a', - '* b', - ' c', - ' []d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - // TODO: in this case command should be disabled and backspace default behaviour should handle it - it( 'if selection is at the beginning of noninitial block of list item proceed by indent', () => { - setData( model, modelList( [ - '* a', - ' * b', - ' * c', - ' * d', - ' []e' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - } ); - - describe( 'selection at the end of a block (forward delete)', () => { - it( 'if followed by a list item of same indentation', () => { - setData( model, modelList( [ - '* a[]', - '* b', - '* c', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - - setData( model, modelList( [ - '* a', - '* b', - '* c[]', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - - setData( model, modelList( [ - '* a', - '* b[]', - '* c', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is followed by other list item of higher indentation', () => { - setData( model, modelList( [ - '* a', - '* b', - ' * c[]', - ' * d', - '* e', - '* f' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is followed by a list item of lower indentation', () => { - setData( model, modelList( [ - '* a', - '* b', - ' * c', - ' * d', - ' * e[]', - '* f', - '* g' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is at the end of the first block of list item', () => { - setData( model, modelList( [ - '* a', - '* b[]', - ' c', - ' d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - // TODO: The only case that forward delete should execute this command - it( 'if selection is at the end of the first block of list item <- rename', () => { - setData( model, modelList( [ - '* a[]', - '* b', - ' c', - ' d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - // TODO: The only case that forward delete should execute this command - it( 'if selection is at the end of the first block of list item <- rename2', () => { - setData( model, modelList( [ - '* a[]', - '* b', - ' * c', - ' d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'if selection is at the end of noninitial block of list item', () => { - setData( model, modelList( [ - '* a', - '* b', - ' c[]', - ' d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - // This case is valid too - it( 'if selection is at the end of the last block of list item that is not part of the last item in a list', () => { - setData( model, modelList( [ - '* a', - '* b', - ' c', - ' d[]', - '* e', - ' f' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); + describe( 'backward', () => { + beforeEach( () => { + command = new DocumentListMergeCommand( editor, 'backward' ); - // This case is valid too - it( 'if selection is at the end of the last block of list item that is not part of the last item in a list 3', () => { - setData( model, modelList( [ - '* a', - '* b', - ' c', - ' d[]', - '* e', - '* f' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - } ); + command.on( 'afterExecute', ( evt, data ) => { + blocksChangedByCommands = data; } ); + } ); - describe( 'when non-collapsed selection', () => { - it( 'if selection is spaning only empty list items', () => { + describe( 'isEnabled', () => { + describe( 'collapsed selection', () => { + it( 'should be false when not in a list item', () => { setData( model, modelList( [ - '* foo', - '* [', - '* ]', - ' c' + 'a[]' ] ) ); - expect( command.isEnabled ).to.be.true; - } ); + expect( command.isEnabled ).to.be.false; - it( 'if selection starts at the end of list item and ends at the start of another', () => { setData( model, modelList( [ - '* a[', - '* ]a', - '* b' + '* a', + '[]b' ] ) ); - expect( command.isEnabled ).to.be.true; + expect( command.isEnabled ).to.be.false; } ); - it( 'if selection ends at the beginning of another list item', () => { + it( 'should be true when there is a preceding list item', () => { setData( model, modelList( [ - '* fo[o', - '* ]a', - '* b' + '* a', + '* []' ] ) ); expect( command.isEnabled ).to.be.true; } ); - describe( 'selection starts at the start of a list item', () => { - it( 'should be enabled when selection ends at the end of another list item', () => { - setData( model, modelList( [ - '* [a', - '* b]', - '* c' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of another list item and spans multiple list items', () => { - setData( model, modelList( [ - '* [a', - '* b', - '* c]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of another list item and spans multiple list items (multiple blocks)', () => { - setData( model, modelList( [ - '* [a', - '* b', - ' c', - '* d]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of indented list item', () => { - setData( model, modelList( [ - '* [a', - '* b', - ' * c]', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the non-initial block of a intended list item', () => { - setData( model, modelList( [ - '* [a', - '* b', - ' * c', - ' d]', - '* e' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection spans intended list item', () => { - setData( model, modelList( [ - '* [a', - '* b', - ' * c', - ' d', - '* e]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends in the middle of list item', () => { - setData( model, modelList( [ - '* [a', - '* te]xt', - '* e' - ] ) ); + it( 'should be false when there is no preceding list item', () => { + setData( model, modelList( [ + '* []' + ] ) ); - expect( command.isEnabled ).to.be.true; - } ); + expect( command.isEnabled ).to.be.false; } ); - describe( 'selection starts at in the middle of a list item', () => { - it( 'should be enabled when selection ends at the end of another list item', () => { - setData( model, modelList( [ - '* te[xt', - '* b]', - '* c' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of another list item and spans multiple list items', () => { - setData( model, modelList( [ - '* te[xt', - '* b', - '* c]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of another list item and spans multiple list items (multiple blocks)', () => { - setData( model, modelList( [ - '* te[xt', - '* b', - ' c', - '* d]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of indented list item', () => { - setData( model, modelList( [ - '* te[xt', - '* b', - ' * c]', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the non-initial block of a intended list item', () => { - setData( model, modelList( [ - '* te[xt', - '* b', - ' * c', - ' d]', - '* e' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection spans intended list item', () => { - setData( model, modelList( [ - '* te[xt', - '* b', - ' * c', - ' d', - '* e]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends in the middle of list item', () => { - setData( model, modelList( [ - '* te[xt', - '* te]xt', - '* e' - ] ) ); + it( 'should be false when there is a preceding block in the same list item', () => { + setData( model, modelList( [ + '* a', + ' []' + ] ) ); - expect( command.isEnabled ).to.be.true; - } ); + expect( command.isEnabled ).to.be.false; } ); + } ); - describe( 'selection starts at the end of a list item', () => { - it( 'should be enabled when selection ends at the end of another list item', () => { - setData( model, modelList( [ - '* a[', - '* b]', - '* c' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of another list item and spans multiple list items', () => { - setData( model, modelList( [ - '* a[', - '* b', - '* c]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of another list item and spans multiple list items (multiple blocks)', () => { - setData( model, modelList( [ - '* a[', - '* b', - ' c', - '* d]' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the end of indented list item', () => { - setData( model, modelList( [ - '* a[', - '* b', - ' * c]', - '* d' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection ends at the non-initial block of a intended list item', () => { - setData( model, modelList( [ - '* a[', - '* b', - ' * c', - ' d]', - '* e' - ] ) ); - - expect( command.isEnabled ).to.be.true; - } ); - - it( 'when selection spans intended list item', () => { - setData( model, modelList( [ - '* a[', - '* b', - ' * c', - ' d', - '* e]' - ] ) ); + describe( 'block object', () => { + it( 'should be false when not in a list item', () => { + setData( model, modelList( [ + '[]' + ] ) ); - expect( command.isEnabled ).to.be.true; - } ); + expect( command.isEnabled ).to.be.false; + } ); - it( 'when selection ends in the middle of list item', () => { - setData( model, modelList( [ - '* a[', - '* te]xt', - '* e' - ] ) ); + it( 'should be true when there is a preceding list item', () => { + setData( model, modelList( [ + '* a', + '* []' + ] ) ); - expect( command.isEnabled ).to.be.true; - } ); + expect( command.isEnabled ).to.be.true; } ); - } ); - } ); - describe( 'disabled', () => { - describe( 'when collapsed selection', () => { - it( 'if selection is at the beginning of the first list item of a list', () => { + it( 'should be false when there is no preceding list item', () => { setData( model, modelList( [ - '* []a', - '* b', - '* c', - '* d' + '* []' ] ) ); expect( command.isEnabled ).to.be.false; } ); - it( 'if selection is not at the beginning nor end of a list item', () => { + it( 'should be false when there is a preceding block in the same list item', () => { setData( model, modelList( [ - '* te[]xt', - '* b', - '* c', - '* d' + '* a', + ' []' ] ) ); expect( command.isEnabled ).to.be.false; + } ); + } ); + describe( 'inline object', () => { + it( 'should be false when not in a list item', () => { setData( model, modelList( [ - '* a', - '* te[]xt', - '* c', - '* d' + '[]' ] ) ); expect( command.isEnabled ).to.be.false; + } ); + it( 'should be false when there is a preceding list item but the selection stays in a single item', () => { setData( model, modelList( [ '* a', - '* b', - '* c', - '* te[]xt' + '* []' ] ) ); expect( command.isEnabled ).to.be.false; } ); - it( 'if selection is not at the beginning nor end of a block', () => { + it( 'should be false when there is no preceding list item', () => { setData( model, modelList( [ - '* a', - '* b', - ' te[]xt' + '* []' ] ) ); expect( command.isEnabled ).to.be.false; } ); - it( 'if selection is outside list', () => { + it( 'should be false when there is a preceding block in the same list item', () => { setData( model, modelList( [ - 'foo[]', '* a', - '* b', - ' c' + ' []' ] ) ); expect( command.isEnabled ).to.be.false; } ); } ); - describe( 'when non-collapsed selection', () => { - it( 'if selection is spaning whole single list item', () => { + describe( 'non-collapsed selection', () => { + it( 'should be false if the selection starts and ends in the same list item but nothing precedes', () => { setData( model, modelList( [ - '* [foo]', - '* a', - '* b', - ' c' + '* [a]b' ] ) ); expect( command.isEnabled ).to.be.false; } ); - it( 'if selection is spaning part of single list item', () => { + it( 'should be false if the selection focuses in a non-list item', () => { setData( model, modelList( [ - '* f[oo]oo', - '* a', - '* b', - ' c' + '* [a', + 'b]' ] ) ); expect( command.isEnabled ).to.be.false; } ); - it( 'if selection is spaning the middle and the end of list item', () => { + it( 'should be true if the selection focuses in a list item', () => { setData( model, modelList( [ - '* fo[ooo]', - '* a', - '* b', - ' c' + '* [a', + '* b]' ] ) ); - expect( command.isEnabled ).to.be.false; - } ); + expect( command.isEnabled ).to.be.true; - it( 'if selection is spaning the start and the middle of single list item', () => { setData( model, modelList( [ - '* [foo]oo', - '* a', - '* b', - ' c' + '[a', + '* b]' ] ) ); - expect( command.isEnabled ).to.be.false; + expect( command.isEnabled ).to.be.true; } ); } ); } ); - } ); - describe( 'execute()', () => { - describe( 'backward delete', () => { + describe( 'execute()', () => { + it( 'should use parent batch', () => { + setData( model, modelList( [ + '* a', + '* []' + ] ) ); + + model.change( writer => { + expect( writer.batch.operations.length, 'before' ).to.equal( 0 ); + + command.execute(); + + expect( writer.batch.operations.length, 'after' ).to.be.above( 0 ); + } ); + } ); + describe( 'single block list item', () => { describe( 'collapsed selection at the beginning of a list item', () => { - describe( 'item before is empty', () => { + describe( 'item before is empty (shouldMergeOnBlocksContentLevel = true)', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}' - ] ) ); + runTest( { + input: [ + '* ', + '* []b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []b {id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); - // Default behaviour of backspace? it( 'should merge empty list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* ', + '* []' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge indented list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}' - ] ) ); + runTest( { + input: [ + '* ', + ' * []a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a {id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge indented empty list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* ', + ' * []' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); + runTest( { + input: [ + '* ', + ' * ', + '* []a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []a{id:002}' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); + runTest( { + input: [ + '* ', + ' * ', + '* []' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []' + ], + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'item before is not empty', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); + runTest( { + input: [ + '* a', + '* []b' + ], + expected: [ + '* a', + ' []b' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge empty list item with with previous list item as a block', () => { - setData( model, modelList( [ - '* a', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + '* []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with parent list item as a block', () => { - setData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); + runTest( { + input: [ + '* a', + ' * []b' + ], + expected: [ + '* a', + ' []b' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item with with parent list item as a block', () => { - setData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous list item with higher indent as a block', () => { - setData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); + runTest( { + input: [ + '* a', + ' * b', + '* []c' + ], + expected: [ + '* a', + ' * b', + ' []c' + ], + changedBlocks: [ 2 ] + } ); } ); it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + ' * b', + '* []' + ], + expected: [ + '* a', + ' * b', + ' []' + ], + changedBlocks: [ 2 ] + } ); } ); it( 'should keep merged list item\'s children', () => { - setData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); + runTest( { + input: [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + expected: [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + changedBlocks: [ 1, 2, 3, 4, 5, 6, 7 ] + } ); } ); } ); } ); describe( 'collapsed selection at the end of a list item', () => { - describe( 'item after is empty', () => { + describe( 'item after is empty (shouldMergeOnBlocksContentLevel = true)', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setData( model, modelList( [ - '* ', - '* []b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}' - ] ) ); + runTest( { + input: [ + '* ', + '* []b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []b{id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); // Default behaviour of backspace? it( 'should merge empty list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* ', + '* []' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge indented list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []a' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}' - ] ) ); + runTest( { + input: [ + '* ', + ' * []a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a {id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge indented empty list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* ', + ' * []' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* ', - ' * ', - '* []a' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}' - ] ) ); + runTest( { + input: [ + '* ', + ' * ', + '* []a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []a{id:002}' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge empty list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* ', - ' * ', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []' - ] ) ); + runTest( { + input: [ + '* ', + ' * ', + '* []' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []' + ], + changedBlocks: [ 1 ] + } ); } ); } ); describe( 'item before is not empty', () => { it( 'should merge non empty list item with with previous list item as a block', () => { - setData( model, modelList( [ - '* a', - '* []b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); + runTest( { + input: [ + '* a', + '* []b' + ], + expected: [ + '* a', + ' []b' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge empty list item with with previous list item as a block', () => { - setData( model, modelList( [ - '* a', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + '* []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented list item with with parent list item as a block', () => { - setData( model, modelList( [ - '* a', - ' * []b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b' - ] ) ); + runTest( { + input: [ + '* a', + ' * []b' + ], + expected: [ + '* a', + ' []b' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge indented empty list item with with parent list item as a block', () => { - setData( model, modelList( [ - '* a', - ' * []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + ' * []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] + } ); } ); it( 'should merge list item with with previous list item with higher indent as a block', () => { - setData( model, modelList( [ - '* a', - ' * b', - '* []c' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c' - ] ) ); + runTest( { + input: [ + '* a', + ' * b', + '* []c' + ], + expected: [ + '* a', + ' * b', + ' []c' + ], + changedBlocks: [ 2 ] + } ); } ); it( 'should merge empty list item with with previous list item with higher indent as a block', () => { - setData( model, modelList( [ - '* a', - ' * b', - '* []' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []' - ] ) ); + runTest( { + input: [ + '* a', + ' * b', + '* []' + ], + expected: [ + '* a', + ' * b', + ' []' + ], + changedBlocks: [ 2 ] + } ); } ); it( 'should keep merged list item\'s children', () => { - setData( model, modelList( [ - '* a', - ' * []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' * c', - ' * d', - ' e', - ' * f', - ' * g', - ' h' - ] ) ); + runTest( { + input: [ + '* a', + ' * []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + expected: [ + '* a', + ' []b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + changedBlocks: [ 1, 2, 3, 4, 5, 6, 7 ] + } ); } ); } ); } ); + } ); - describe( 'non-collapsed selection starting in first block of a list item', () => { - describe( 'first position in empty block', () => { - it( 'should merge two empty list items', () => { - setData( model, modelList( [ - '* [', - '* ]' - ] ) ); - - command.execute(); + describe( 'multi-block list item', () => { + describe( 'collapsed selection at the beginning of a list item', () => { + describe( 'item before is empty (shouldMergeOnBlocksContentLevel = true)', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + runTest( { + input: [ + '* ', + '* []b', + ' c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []b{id:001}', + ' c' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should merge with previous list item and keep complex blocks intact ', () => { + runTest( { + input: [ + '* ', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []b {id:001}', + ' c', + ' * d {id:003}', + ' e', + ' * f {id:005}', + ' * g {id:006}', + ' h', + ' * i {id:008}', + ' * j {id:009}', + ' k', + ' l' + ], + changedBlocks: [ 0, 1, 10 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + it( 'should merge list item with first block empty with previous empty list item', () => { + runTest( { + input: [ + '* ', + '* []', + ' a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + ' a' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - it( 'should merge non empty list item', () => { - setData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + it( 'should merge indented list item with with previous empty list item', () => { + runTest( { + input: [ + '* ', + ' * []a', + ' b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a {id:001}', + ' b' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - it( 'should merge non empty list item and delete text', () => { - setData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + runTest( { + input: [ + '* ', + ' * []a', + ' b', + ' * c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ], + changedBlocks: [ 0, 1, 2 ] + } ); + } ); - command.execute(); + it( 'should merge indented empty list item with previous empty list item', () => { + runTest( { + input: [ + '* ', + ' * []', + ' text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + ' text' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + it( 'should merge list item with with previous indented empty list item', () => { + runTest( { + input: [ + '* ', + ' * ', + '* []a', + ' b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []a{id:002}', + ' b' + ], + changedBlocks: [ 1, 2 ] + } ); } ); - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * ]b' - ] ) ); + it( 'should merge empty list item with with previous indented empty list item', () => { + runTest( { + input: [ + '* ', + ' * ', + '* []', + ' text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []', + ' text' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + } ); - command.execute(); + describe( 'item before is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + runTest( { + input: [ + '* a', + '* []b', + ' c' + ], + expected: [ + '* a', + ' []b', + ' c' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + + it( 'should merge block to a previous list item', () => { + runTest( { + input: [ + '* b', + ' * c', + ' []d', + ' e' + ], + expected: [ + '* b', + ' * c', + ' []d', + ' e' + ], + changedBlocks: [ 2 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:002}' - ] ) ); + it( 'should merge with previous list item and keep complex blocks intact', () => { + runTest( { + input: [ + '* a', + '* []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + expected: [ + '* a', + ' []b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + changedBlocks: [ 1, 2, 11 ] + } ); } ); - it( 'should merge and adjust indentation of child list items', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); + it( 'should merge list item with first block empty with previous list item', () => { + runTest( { + input: [ + '* a', + '* []', + ' b' + ], + expected: [ + '* a', + ' []', + ' b' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); - command.execute(); + it( 'should merge indented list item with with previous list item as blocks', () => { + runTest( { + input: [ + '* a', + ' * []a', + ' b' + ], + expected: [ + '* a', + ' []a', + ' b' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + it( 'should merge indented list having block and indented list item with previous list item', () => { + runTest( { + input: [ + '* a', + ' * []b', + ' c', + ' * d' + ], + expected: [ + '* a', + ' []b', + ' c', + ' * d' + ], + changedBlocks: [ 1, 2, 3 ] + } ); } ); - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); + it( 'should merge indented empty list item with previous list item', () => { + runTest( { + input: [ + '* a', + ' * []', + ' text' + ], + expected: [ + '* a', + ' []', + ' text' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); - command.execute(); + it( 'should merge list item with with previous indented empty list item', () => { + runTest( { + input: [ + '* a', + ' * b', + '* []c', + ' d' + ], + expected: [ + '* a', + ' * b', + ' []c', + ' d' + ], + changedBlocks: [ 2, 3 ] + } ); + } ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + describe( 'collapsed selection in the middle of the list item', () => { + it( 'should merge block to a previous list item', () => { + runTest( { + input: [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ], + expected: [ + '* A', + ' * B', + ' # C', + ' # D', + ' []X', + ' # Z', + ' V', + '* E', + '* F' + ], + changedBlocks: [ 4, 5 ] } ); + } ); + } ); + } ); - it( 'should delete all items till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', + describe( 'around widgets', () => { + describe( 'block widgets', () => { + it( 'should merge a selected block widget into a block', () => { + runTest( { + input: [ '* a', - ' * b', - '* ]d' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []d{id:003}' - ] ) ); + '* []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] } ); + } ); - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', + it( 'should merge into a nested block with a block widget', () => { + runTest( { + input: [ '* a', - ' * b', - '* d]e' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + ' * []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] } ); } ); - describe( 'first position in non-empty block', () => { - it( 'should merge two list items', () => { - setData( model, modelList( [ - '* [text', - '* ano]ther' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}' - ] ) ); + it( 'should merge an item into the previous one despite a block widget precededing it', () => { + runTest( { + input: [ + '* a', + ' ', + '* []' + ], + expected: [ + '* a', + ' ', + ' []' + ], + changedBlocks: [ 2 ] } ); + } ); - it( 'should merge two list itemsx TODO', () => { - setData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); + it( 'should merge an item into the previous one despite a block widget precededing it at a deeper level', () => { + runTest( { + input: [ + '* a', + ' * ', + '* []' + ], + expected: [ + '* a', + ' * ', + ' []' + ], + changedBlocks: [ 2 ] } ); + } ); - it( 'should merge non empty list item', () => { - setData( model, modelList( [ - '* text[', - '* ]another' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]another{id:001}' - ] ) ); + it( 'should merge an item into the previous one (down) despite a block widget precededing it at a lower level', () => { + runTest( { + input: [ + '* a', + ' * ', + ' * []' + ], + expected: [ + '* a', + ' * ', + ' []' + ], + changedBlocks: [ 2 ] } ); + } ); - it( 'should merge non empty list item and delete text', () => { - setData( model, modelList( [ - '* text[', - '* ano]ther' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]ther{id:001}' - ] ) ); + it( 'should merge into a block with a block widget', () => { + runTest( { + input: [ + '* ', + '* a[]' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: false + }, + expected: [ + '* ', + ' a[]' + ], + changedBlocks: [ 1 ] } ); + } ); + } ); - it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setData( model, modelList( [ - '* text[', - '* a', - ' * ]b', - ' * c' - ] ) ); - - command.execute(); - // output is okay, fix expect - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]b', - ' * c{id:003}' - ] ) ); + describe( 'inline images', () => { + it( 'should merge an empty list item into preceding list item containing an inline widget', () => { + runTest( { + input: [ + '* a', + '* []' + ], + expected: [ + '* a', + ' []' + ], + changedBlocks: [ 1 ] } ); + } ); + } ); + } ); + } ); + } ); - it( 'should merge and adjust indentation of child list items', () => { - setData( model, modelList( [ - '* text[', - '* a', - ' * b]c', - ' * d' - ] ) ); + describe( 'forward', () => { + beforeEach( () => { + command = new DocumentListMergeCommand( editor, 'forward' ); - command.execute(); + command.on( 'afterExecute', ( evt, data ) => { + blocksChangedByCommands = data; + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]c', - ' * d{id:003}' - ] ) ); - } ); + describe( 'isEnabled', () => { + describe( 'collapsed selection', () => { + it( 'should be false when not in a list item', () => { + setData( model, modelList( [ + 'a[]' + ] ) ); - it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setData( model, modelList( [ - '* text[', - '* a', - ' * bc]', - ' * d' - ] ) ); + expect( command.isEnabled ).to.be.false; - command.execute(); + setData( model, modelList( [ + '[]a', + '* b' + ] ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]{id:000}', - ' * d{id:003}' - ] ) ); - } ); + expect( command.isEnabled ).to.be.false; + } ); - it( 'should delete all items till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* ]d' - ] ) ); + it( 'should be true when there is a following list item', () => { + setData( model, modelList( [ + '* []', + '* a' + ] ) ); - command.execute(); + expect( command.isEnabled ).to.be.true; + } ); - // output is okay, fix expect - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]d{id:003}' - ] ) ); - } ); + it( 'should be false when there is no following list item', () => { + setData( model, modelList( [ + '* []' + ] ) ); - it( 'should delete all items and text till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* text[', - '* a', - ' * b', - '* d]e' - ] ) ); + expect( command.isEnabled ).to.be.false; + } ); - command.execute(); + it( 'should be false when there is a following block in the same list item', () => { + setData( model, modelList( [ + '* []', + ' a' + ] ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* text[]e{id:003}' - ] ) ); - } ); - } ); + expect( command.isEnabled ).to.be.false; } ); } ); - describe( 'multi-block list item', () => { - describe( 'collapsed selection at the beginning of a list item', () => { - describe( 'item before is empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setData( model, modelList( [ - '* ', - '* []b', - ' c' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []b{id:001}', - ' c' - ] ) ); - } ); + describe( 'block object', () => { + it( 'should be false when not in a list item', () => { + setData( model, modelList( [ + '[]' + ] ) ); - it( 'should merge with previous list item and keep complex blocks intact', () => { - setData( model, modelList( [ - '* ', - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []b', - ' c', - ' * d', - ' e', - ' * f', - ' * g{', - ' h', - ' * i', - ' * j', - ' k', - ' l' - ] ) ); - } ); - - // TODO: fix ids???? - it( 'should merge list item with first block empty with previous empty list item', () => { - setData( model, modelList( [ - '* ', - '* []', - ' a' - ] ) ); + expect( command.isEnabled ).to.be.false; + } ); - command.execute(); + it( 'should be true when there is a following list item', () => { + setData( model, modelList( [ + '* []', + '* a' + ] ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:001}', - ' a' - ] ) ); - } ); + expect( command.isEnabled ).to.be.true; + } ); - it( 'should merge indented list item with with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []a', - ' b' - ] ) ); + it( 'should be false when there is no following list item', () => { + setData( model, modelList( [ + '* []' + ] ) ); - command.execute(); + expect( command.isEnabled ).to.be.false; + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}', - ' b' - ] ) ); - } ); + it( 'should be false when there is a following block in the same list item', () => { + setData( model, modelList( [ + '* []', + ' a' + ] ) ); - it( 'should merge indented list having block and indented list item with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []a', - ' b', - ' * c' - ] ) ); + expect( command.isEnabled ).to.be.false; + } ); + } ); - command.execute(); + describe( 'non-collapsed selection', () => { + it( 'should be false if the selection focuses in a non-list item', () => { + setData( model, modelList( [ + '* [a', + 'b]' + ] ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []a{id:001}', - ' b', - ' * c' - ] ) ); - } ); + expect( command.isEnabled ).to.be.false; + } ); - it( 'should merge indented empty list item with previous empty list item', () => { - setData( model, modelList( [ - '* ', - ' * []', - ' text' - ] ) ); + it( 'should be true if the selection focuses in a list item', () => { + setData( model, modelList( [ + '* [a', + '* b]' + ] ) ); - command.execute(); + expect( command.isEnabled ).to.be.true; - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []', - ' text' - ] ) ); - } ); + setData( model, modelList( [ + '[a', + '* b]' + ] ) ); - it( 'should merge list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* ', - ' * ', - '* []a', - ' b' - ] ) ); + // Because deleteContent must happen. + expect( command.isEnabled ).to.be.true; + } ); + } ); + } ); - command.execute(); + describe( 'execute()', () => { + it( 'should use parent batch', () => { + setData( model, modelList( [ + '* []', + '* a' + ] ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []a{id:002}', - ' b' - ] ) ); - } ); + model.change( writer => { + expect( writer.batch.operations.length, 'before' ).to.equal( 0 ); - it( 'should merge empty list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* ', - ' * ', - '* []', - ' text' - ] ) ); + command.execute(); - command.execute(); + expect( writer.batch.operations.length, 'after' ).to.be.above( 0 ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* ', - ' * []', - ' text' - ] ) ); + describe( 'single block list item', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it( 'should remove next empty list item', () => { + runTest( { + input: [ + '* b[]', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* b[]' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove next empty list item when current is empty', () => { + runTest( { + input: [ + '* []', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove current list item if empty and replace with indented', () => { + runTest( { + input: [ + '* []', + ' * a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a {id:001}' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove next empty indented item list', () => { + runTest( { + input: [ + '* []', + ' * ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should replace current empty list item with next list item', () => { + runTest( { + input: [ + '* ', + ' * []', + '* a' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []a{id:002}' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should remove next empty list item when current is also empty', () => { + runTest( { + input: [ + '* ', + ' * []', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []' + ], + changedBlocks: [ 1 ] + } ); } ); } ); - describe( 'item before is not empty', () => { - it( 'should merge with previous list item and keep blocks intact', () => { - setData( model, modelList( [ - '* a', - '* []b', - ' c' - ] ) ); - - command.execute(); + describe( 'next list item is not empty', () => { + it( 'should merge text from next list item with current list item text', () => { + runTest( { + input: [ + '* a[]', + '* b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]b' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should delete next empty item list', () => { + runTest( { + input: [ + '* a[]', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge text of indented list item with current list item', () => { + runTest( { + input: [ + '* a[]', + ' * b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]b' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove indented empty list item', () => { + runTest( { + input: [ + '* a[]', + ' * ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge text of lower indent list item', () => { + runTest( { + input: [ + '* a', + ' * b[]', + '* c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b[]c' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should delete next empty list item with lower ident', () => { + runTest( { + input: [ + '* a', + ' * b[]', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b[]' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge following item list of first block and adjust it\'s children', () => { + runTest( { + input: [ + '* a[]', + ' * b', + ' * c', + ' * d', + ' e', + ' * f', + ' * g', + ' h' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]b', + ' * c {id:002}', + ' * d {id:003}', + ' e', + ' * f {id:005}', + ' * g {id:006}', + ' h' + ], + changedBlocks: [ 0, 1, 2, 3, 4, 5, 6 ] + } ); + } ); + + it( 'should merge following first block of an item list and make second block a first one', () => { + runTest( { + input: [ + '* a[]', + ' * b', + ' b2', + ' * c', + ' * d', + ' e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]b', + ' b2', + ' * c {id:003}', + ' * d {id:004}', + ' e' + ], + changedBlocks: [ 0, 1, 2, 3, 4 ] + } ); + } ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c' - ] ) ); + describe( 'non-collapsed selection starting in first block of a list item', () => { + describe( 'first position in empty block', () => { + it( 'should merge two empty list items', () => { + runTest( { + input: [ + 'a', + '* [', + '* ]' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + 'a', + '* []' + ], + changedBlocks: [ 1 ] + } ); } ); - it( 'should TODO', () => { - setData( model, modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); + it( 'should merge non empty list item', () => { + runTest( { + input: [ + '* [', + '* ]text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []text{id:001}' + ], + changedBlocks: [ 0 ] + } ); + } ); - command.execute(); + it( 'should merge non empty list item and delete text', () => { + runTest( { + input: [ + '* [', + '* te]xt' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []xt{id:001}' + ], + changedBlocks: [ 0 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' []d', - ' e' - ] ) ); + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + runTest( { + input: [ + '* [', + '* a', + ' * ]b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* b {id:002}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - it( 'should merge with previous list item and keep complex blocks intact', () => { - setData( model, modelList( [ - '* a', - '* []b{id:b}', - ' c', - ' * d{id:d}', - ' e', - ' * f{id:f}', - ' * g{id:g}', - ' h', - ' * i{id:i}', - ' * j{id:j}', - ' k', - ' l' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b{id:b}', - ' c', - ' * d{id:d}', - ' e', - ' * f{id:f}', - ' * g{id:g}', - ' h', - ' * i{id:i}', - ' * j{id:j}', - ' k', - ' l' - ] ) ); + it( 'should merge and adjust indentation of child list items', () => { + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - it( 'should merge list item with first block empty with previous list item', () => { - setData( model, modelList( [ - '* a', - '* []{id:000}', - ' b' - ] ) ); + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []{id:000}', + ' * d{id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); - command.execute(); + it( 'should delete all items till the end of selection and merge last list item', () => { + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* d {id:003}' + ], + changedBlocks: [ 0 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' b' - ] ) ); + it( 'should delete all items and text till the end of selection and merge last list item', () => { + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []e{id:003}' + ], + changedBlocks: [ 0 ] + } ); } ); + } ); - it( 'should merge indented list item with with previous list item as blocks', () => { - setData( model, modelList( [ - '* a', - ' * []a', - ' b' - ] ) ); + describe( 'first position in non-empty block', () => { + it( 'should merge two list items', () => { + runTest( { + input: [ + '* [text', + '* ano]ther' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []ther{id:001}' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge two list items if selection starts in the middle of text', () => { + runTest( { + input: [ + '* te[xt', + '* ano]ther' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* te[]ther' + ], + changedBlocks: [ 0 ] + } ); + } ); - command.execute(); + it( 'should merge non empty list item', () => { + runTest( { + input: [ + '* text[', + '* ]another' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[]another' + ], + changedBlocks: [ 0 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []a', - ' b' - ] ) ); + it( 'should merge non empty list item and delete text', () => { + runTest( { + input: [ + '* text[', + '* ano]ther' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[]ther' + ], + changedBlocks: [ 0 ] + } ); } ); - it( 'should merge indented list having block and indented list item with previous list item', () => { - setData( model, modelList( [ - '* a', - ' * []b', - ' c', - ' * d' - ] ) ); + it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { + runTest( { + input: [ + '* text[', + '* a', + ' * ]b', + ' * c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[]', + '* b {id:002}', + ' * c {id:003}' + ], + changedBlocks: [ 0, 1, 2 ] + } ); + } ); - command.execute(); + it( 'should merge and adjust indentation of child list items', () => { + runTest( { + input: [ + '* text[', + '* a', + ' * b]c', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[]c', + ' * d {id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []b', - ' c', - ' * d' - ] ) ); + it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { + runTest( { + input: [ + '* text[', + '* a', + ' * bc]', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[] {id:000}', + ' * d {id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - it( 'should merge indented empty list item with previous list item', () => { - setData( model, modelList( [ - '* a', - ' * []', - ' text' - ] ) ); + it( 'should delete all items till the end of selection and merge last list item', () => { + runTest( { + input: [ + '* text[', + '* a', + ' * b', + '* ]d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[]', + '* d {id:003}' + ], + changedBlocks: [ 0 ] + } ); + } ); - command.execute(); + it( 'should delete all items and text till the end of selection and merge last list item', () => { + runTest( { + input: [ + '* text[', + '* a', + ' * b', + '* d]e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* text[]e' + ], + changedBlocks: [ 0 ] + } ); + } ); + } ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' []', - ' text' - ] ) ); + describe( 'multi-block list item', () => { + describe( 'collapsed selection at the end of a list item', () => { + describe( 'item after is empty', () => { + it( 'should remove empty list item', () => { + runTest( { + input: [ + '* a', + ' b[]', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' b[]' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge following complex list item with current one', () => { + runTest( { + input: [ + '* ', + ' []', + '* b', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + '* []b {id:002}', + ' c', + ' * d {id:d}', + ' e', + ' * f {id:f}', + ' * g {id:g}', + ' h', + ' * i {id:i}', + ' * j {id:j}', + ' k', + ' l' + ], + changedBlocks: [ 1, 2, 11 ] + } ); + } ); + + it( 'should merge indented list item with with currently selected list item', () => { + runTest( { + input: [ + '* []', + ' * a', + ' b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a{id:001}', + ' b' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - it( 'should merge list item with with previous indented empty list item', () => { - setData( model, modelList( [ - '* a', - ' * b', - '* []c', - ' d' - ] ) ); + it( 'should merge indented list having block and indented list item with previous empty list item', () => { + runTest( { + input: [ + '* []', + ' * a', + ' b', + ' * c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []a {id:001}', + ' b', + ' * c {id:003}' + ], + changedBlocks: [ 0, 1, 2 ] + } ); + } ); + + it( 'should merge indented list item with first block empty', () => { + runTest( { + input: [ + '* []', + ' * ', + ' text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + ' text' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should merge next outdented list item', () => { + runTest( { + input: [ + '* ', + ' * []', + '* a', + ' b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []a {id:002}', + ' b' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + + it( 'should merge next outdented list item with first block empty', () => { + runTest( { + input: [ + '* ', + ' * []', + '* ', + ' text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* ', + ' * []', + ' text' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + } ); - command.execute(); + describe( 'list item after is not empty', () => { + it( 'should merge with previous list item and keep blocks intact', () => { + runTest( { + input: [ + '* a[]', + '* b', + ' c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]b', + ' c' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should merge all following outdented blocks', () => { + runTest( { + input: [ + '* b', + ' * c', + ' c2[]', + ' d', + ' e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* b', + ' * c', + ' c2[]d', + ' e' + ], + changedBlocks: [ 2, 3 ] + } ); + } ); + + it( 'should merge complex list item', () => { + runTest( { + input: [ + '* a', + ' a2[]', + '* b', + ' c', + ' * d', + ' e', + ' * f', + ' * g', + ' h', + ' * i', + ' * j', + ' k', + ' l' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' a2[]b', + ' c', + ' * d {id:004}', + ' e', + ' * f {id:006}', + ' * g {id:007}', + ' h', + ' * i {id:009}', + ' * j {id:010}', + ' k', + ' l' + ], + changedBlocks: [ 1, 2, 11 ] + } ); + } ); + + it( 'should merge list item with next multi-block list item', () => { + runTest( { + input: [ + '* a', + ' a2[]', + '* b', + ' b2' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' a2[]b', + ' b2' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + + it( 'should merge outdented multi-block list item', () => { + runTest( { + input: [ + '* a', + ' a2[]', + ' * b', + ' b2' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' a2[]b', + ' b2' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + + it( 'should merge an outdented list item in an outdented list item', () => { + runTest( { + input: [ + '* a', + ' * b', + ' c[]', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b', + ' c[]d' + ], + changedBlocks: [ 2 ] + } ); + } ); + + it( 'should merge indented empty list item', () => { + runTest( { + input: [ + '* a', + ' * b', + ' c[]', + ' * ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b', + ' c[]' + ], + changedBlocks: [ 2 ] + } ); + } ); + + it( 'should merge list item with with next outdented list item', () => { + runTest( { + input: [ + '* a', + ' * b[]', + '* c', + ' d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b[]c', + ' d' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' * b', - ' []c', - ' d' - ] ) ); + describe( 'collapsed selection in the middle of the list item', () => { + it( 'should merge next indented list item', () => { + runTest( { + input: [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]', + ' # Z', + ' V', + '* E', + '* F' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* A', + ' * B', + ' # C', + ' # D', + ' X[]Z', + ' V', + '* E {id:007}', + '* F {id:008}' + ], + changedBlocks: [ 4 ] } ); } ); } ); @@ -1626,487 +2231,833 @@ describe.skip( 'DocumentListMergeCommand', () => { describe( 'non-collapsed selection starting in first block of a list item', () => { describe( 'first position in empty block', () => { it( 'should merge two empty list items', () => { - setData( model, modelList( [ - '* [', - '* ]', - ' ' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []' - ] ) ); + runTest( { + input: [ + '* [', + '* ]', + ' ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + ' ' + ], + changedBlocks: [ 0, 1 ] + } ); } ); it( 'should merge non empty list item', () => { - setData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []text {id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []xt {id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setData( model, modelList( [ - '* [{id:002}', - '* a', - ' * ]b' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:002}', - ' b' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* b {id:002}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []c {id:002}', + ' * d {id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* [] {id:000}', + ' * d {id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - // I DON'T LIKE THIS EXPECTED OUTPUT it( 'should delete all items till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* d {id:003}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []e{id:003}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should delete all following items till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', - ' text', - '* a', - ' * b', - '* d]e' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:004}' - ] ) ); - } ); - - // I DON'T LIKE THIS OUTPUT - it( 'should delete all following items till the end of selection and merge last list itemxx', () => { - setData( model, modelList( [ - '* [', - ' * b', - ' ]c', - ' * d', - ' e' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* c', - ' * d{id:003}', - ' e' - ] ) ); + runTest( { + input: [ + '* [', + ' text', + '* a', + ' * b', + '* d]e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []e {id:004}' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should delete all following items till the end of selection and merge last list itemx', () => { + runTest( { + input: [ + '* [', + ' * b', + ' ]c', + ' * d', + ' e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* c', + ' * d {id:003}', + ' e' + ], + changedBlocks: [ 0, 1, 2, 3 ] + } ); } ); it( 'should delete items till the end of selection and merge middle block with following blocks', () => { - setData( model, modelList( [ - '* [', - ' * b', - ' c]d', - ' * e', - ' f' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []d{id:001}', - ' * e{id:003}', - ' f' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' c]d', + ' * e', + ' f' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []d {id:001}', + ' * e {id:003}', + ' f' + ], + changedBlocks: [ 0, 1, 2 ] + } ); } ); it( 'should delete items till the end of selection and merge following blocks', () => { - setData( model, modelList( [ - '* [{id:001}', - ' * b', - ' cd]', - ' * e', - ' f', - ' s' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:001}', - ' * e{id:003}', - ' f', - ' s' - ] ) ); + runTest( { + input: [ + '* [', + ' * b', + ' cd]', + ' * e', + ' f', + ' s' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + ' * e {id:003}', + ' f', + '* s {id:001}' + ], + changedBlocks: [ 0, 1, 2, 3 ] + } ); } ); } ); describe( 'first position in non-empty block', () => { it( 'should merge two list items', () => { - setData( model, modelList( [ - '* [text', - '* ano]ther', - ' text' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []ther{id:001}', - ' text' - ] ) ); + runTest( { + input: [ + '* [text', + '* ano]ther', + ' text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []ther {id:001}', + ' text' + ], + changedBlocks: [ 0, 1 ] + } ); } ); // Not related to merge command it( 'should merge two list items with selection in the middle', () => { - setData( model, modelList( [ - '* te[xt', - '* ano]ther' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* te[]ther' - ] ) ); + runTest( { + input: [ + '* te[xt', + '* ano]ther' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* te[]ther' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge non empty list item', () => { - setData( model, modelList( [ - '* [', - '* ]text' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []text{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* ]text' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []text {id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge non empty list item and delete text', () => { - setData( model, modelList( [ - '* [', - '* te]xt' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []xt{id:001}' - ] ) ); + runTest( { + input: [ + '* [', + '* te]xt' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []xt{id:001}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should merge and adjust indentation of child list item when end selection is at the beginning of item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * ]b', - ' * c' - ] ) ); - - command.execute(); - // output is okay, fix expect - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* b{id:002}', - ' * c{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * ]b', + ' * c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* b {id:002}', + ' * c {id:003}' + ], + changedBlocks: [ 0, 1, 2 ] + } ); } ); it( 'should merge and adjust indentation of child list items', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b]c', - ' * d' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []c{id:002}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]c', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []c{id:002}', + ' * d{id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); it( 'should merge and adjust indentation of child list items when selection at the end of an item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * bc]', - ' * d' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:000}', - ' * d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * bc]', + ' * d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* [] {id:000}', + ' * d {id:003}' + ], + changedBlocks: [ 0, 1 ] + } ); } ); - // I DONT LIKE EXPECTED OUTPUT it( 'should delete all items till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b', - '* ]d' - ] ) ); - - command.execute(); - - // output is okay, fix expect - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []', - '* d{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* ]d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + '* d {id:003}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should delete all items and text till the end of selection and merge last list item', () => { - setData( model, modelList( [ - '* [', - '* a', - ' * b', - '* d]e' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []e{id:003}' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b', + '* d]e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []e{id:003}' + ], + changedBlocks: [ 0 ] + } ); } ); it( 'should delete all items and text till the end of selection and adjust orphan elements', () => { - setData( model, modelList( [ - '* [{id:001}', - '* a', - ' * b]{id:001}', - ' c', - ' * d', - ' e', - ' f' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* []{id:001}', - ' c', - ' * d{id:004}', - ' e', - ' f' - ] ) ); + runTest( { + input: [ + '* [', + '* a', + ' * b]', + ' c', + ' * d', + ' e', + ' f', + ' g' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []', + ' c', + ' * d {id:004}', + ' e', + '* f {id:001}', + ' g' + ], + changedBlocks: [ 0, 1, 2, 3 ] + } ); } ); } ); } ); } ); - } ); - - describe( 'forward delete', () => { - it( 'xx', () => { - setData( model, modelList( [ - '* a[]', - '* b', - '* c' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a[]b', - '* c' - ] ) ); - } ); - - it( 'xxx', () => { - setData( model, modelList( [ - '* a[]', - '* b', - ' c' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - ' b', - ' c' - ] ) ); - } ); - - it( 'xxxx', () => { - setData( model, modelList( [ - '* a[]', - ' * b', - ' c' - ] ) ); - - command.execute(); - - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a[]', - ' b', - ' c' - ] ) ); - } ); - - it( 'xxxxx', () => { - setData( model, modelList( [ - '* a', - ' b[]', - '* c', - ' d' - ] ) ); - command.execute(); + describe( 'selection outside list', () => { + describe( 'non-collapsed selection', () => { + describe( 'only end in a list', () => { + it( 'should delete everything till end of selection', () => { + runTest( { + input: [ + '[', + '* te]xt' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* []xt {id:001}' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should delete everything till the end of selection and adjust remaining block to item list', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + 'a[]b', + '* c' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should delete everything till the end of selection and adjust remaining item list indentation', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' * c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + 'a[]b', + ' * c {id:002}' + ], + // Note: Technically speaking "c" should also be included but wasn't; was fixed by model post-fixer. + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should delete selection and adjust remaining item list indentation (multi-block)', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' * c', + ' d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + 'a[]b', + ' * c {id:002}', + ' d' + ], + // Note: Technically speaking "c" and "d" should also be included but weren't; fixed by model post-fixer. + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove selection and adjust remaining list', () => { + runTest( { + input: [ + 'a[', + '* b]b', + ' * c', + ' d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + 'a[]b', + ' * c {id:002}', + '* d {id:001}' + ], + // Note: Technically speaking "c" and "d" should also be included but weren't; fixed by model post-fixer. + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should remove selection and adjust remaining list (multi-block)', () => { + runTest( { + input: [ + 'a[', + '* b', + ' * c', + ' d]d', + ' * e', + ' f' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + 'a[]d', + ' * e {id:004}', + ' f' + ], + changedBlocks: [ 0, 1, 2 ] + } ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]', - ' c', - ' d' - ] ) ); + describe( 'spanning multiple lists', () => { + it( 'should merge lists into one with one list item', () => { + runTest( { + input: [ + '* a[a', + 'b', + '* c]c' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]c' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge lists into one with two blocks', () => { + runTest( { + input: [ + '* a', + ' b[b', + 'c', + '* d]d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' b[]d' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge two lists into one with two list items', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d]', + '* e' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]', + '* e {id:003}' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge two lists into one with two list items (multiple blocks)', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d]', + ' e', + '* f' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]', + ' e', + '* f {id:004}' + ], + changedBlocks: [ 0, 1 ] + } ); + } ); + + it( 'should merge two lists into one with two list items and adjust indentation', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]e', + ' * f {id:004}', + ' g' + ], + changedBlocks: [ 0, 1, 2 ] + } ); + } ); + + it( 'should merge two lists into one with deeper indendation', () => { + runTest( { + input: [ + '* a', + ' * b[', + 'c', + '* d', + ' * e', + ' * f]f', + ' * g' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b[]f', + ' * g {id:006}' + ], + changedBlocks: [ 1, 2 ] + } ); + } ); + + it( 'should merge two lists into one with deeper indentation (multiple blocks)', () => { + runTest( { + input: [ + '* a', + ' * b[', + 'c', + '* d', + ' * e]e', + ' * f', + ' g' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + ' * b[]e', + ' * f {id:005}', + ' g' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge two lists into one and keep items after selection', () => { + runTest( { + input: [ + '* a[', + 'c', + '* d', + ' * e]e', + '* f', + ' g' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]e', + '* f {id:004}', + ' g' + ], + changedBlocks: [ 0 ] + } ); + } ); + + it( 'should merge lists of different types to a single list and keep item lists types', () => { + runTest( { + input: [ + '* a', + '* b[b', + 'c', + '# d]d', + '# d' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + '* b[]d', + '# d {id:004}' + ], + changedBlocks: [ 1 ] + } ); + } ); + + it( 'should merge lists of mixed types to a single list and keep item lists types', () => { + runTest( { + input: [ + '* a', + '# b[b', + 'c', + '# d]d', + ' * f' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a', + '# b[]d', + ' * f {id:004}' + ], + changedBlocks: [ 1 ] + } ); + } ); + } ); + } ); } ); - it( 'xxxxxx', () => { - setData( model, modelList( [ - '* a', - ' b[]', - ' * c', - '* b', - ' c' - ] ) ); + describe( 'around widgets', () => { + describe( 'block widgets', () => { + it( 'should merge into a block with a block widget', () => { + runTest( { + input: [ + '* a[]', + '* ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: false + }, + expected: [ + '* a[]', + ' ' + ], + changedBlocks: [ 1 ] + } ); + } ); - command.execute(); + it( 'should merge into a nested block with a block widget', () => { + runTest( { + input: [ + '* a[]', + ' * ' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: false + }, + expected: [ + '* a[]', + ' ' + ], + changedBlocks: [ 1 ] + } ); + } ); + } ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]', - ' c', - '* b', - ' c' - ] ) ); + describe( 'inline images', () => { + it( 'should merge a list item into following list item containing an inline widget', () => { + runTest( { + input: [ + '* a[]', + '* b' + ], + commandOptions: { + shouldMergeOnBlocksContentLevel: true + }, + expected: [ + '* a[]b' + ], + changedBlocks: [ 0 ] + } ); + } ); + } ); } ); + } ); + } ); - it( 'xxxxxxx', () => { - setData( model, modelList( [ - '* a', - ' b[]', - ' * c', - '* b', - ' c' - ] ) ); - - command.execute(); + // @param {Iterable.} input + // @param {Iterable.} expected + // @param {Array.} changedBlocks Indexes of changed blocks. + function runTest( { input, commandOptions, expected, changedBlocks = [] } ) { + setData( model, modelList( input ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* a', - ' b[]', - ' c', - '* b', - ' c' - ] ) ); - } ); + if ( !command.isEnabled ) { + throw new Error( 'Yikes. The command is disabled but should be executed.' ); + } - it( 'xxxxxxxx', () => { - setData( model, modelList( [ - '* []', - ' b', - ' * c', - ' * b', - ' c' - ] ) ); + command.execute( commandOptions ); - command.execute(); + expect( getData( model ) ).to.equalMarkup( modelList( expected ) ); - expect( getData( model ) ).to.equalMarkup( modelList( [ - '* b', - ' * c', - ' * b', - ' c' - ] ) ); - } ); - } ); - } ); + expect( blocksChangedByCommands.map( block => block.index ) ).to.deep.equal( changedBlocks, 'changed blocks\' indexes' ); + } } ); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index eaa0ea6d3a3..8859525a524 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -6578,7 +6578,6 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { // @param {Object.} executedCommands Numbers of command executions. // @param {Array.} changedBlocks Indexes of changed blocks. function runTest( { input, expected, eventStopped, executedCommands = {}, changedBlocks = [] } ) { - // console.log( 'in', modelList( input ) ); setModelData( model, modelList( input ) ); view.document.fire( eventInfo, domEventData ); diff --git a/packages/ckeditor5-list/tests/manual/listmocking.js b/packages/ckeditor5-list/tests/manual/listmocking.js index 82ad62b5322..8b8e741e74f 100644 --- a/packages/ckeditor5-list/tests/manual/listmocking.js +++ b/packages/ckeditor5-list/tests/manual/listmocking.js @@ -34,6 +34,7 @@ ClassicEditor editor.model.schema.register( 'blockWidget', { isObject: true, + isBlock: true, allowIn: '$root', allowAttributesOf: '$container' } ); From 39edfaeb41d3cbfb116a00b21becc1441d28117b Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 12:04:03 +0100 Subject: [PATCH 33/44] Code refactoring. --- packages/ckeditor5-list/theme/documentlist.css | 4 ---- 1 file changed, 4 deletions(-) diff --git a/packages/ckeditor5-list/theme/documentlist.css b/packages/ckeditor5-list/theme/documentlist.css index 965ce9d501c..860bcdd0748 100644 --- a/packages/ckeditor5-list/theme/documentlist.css +++ b/packages/ckeditor5-list/theme/documentlist.css @@ -4,9 +4,5 @@ */ .ck-editor__editable .ck-list-bogus-paragraph { - /* - * Use display:inline-block to force Chrome/Safari to limit text mutations to this element. - * See https://github.com/ckeditor/ckeditor5/issues/6062. - */ display: block; } From 62ce46ef1cedb42f5f2fcfdb3baa97608bc52699 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 12:23:35 +0100 Subject: [PATCH 34/44] Code refactoring. --- .../src/documentlist/utils/model.js | 36 +++++++------------ .../tests/documentlist/utils/model.js | 6 ++-- 2 files changed, 15 insertions(+), 27 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 5f15e729922..b37ee0f1c54 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -162,7 +162,6 @@ export function isLastBlockOfListItem( listBlock ) { * @protected * @param {module:engine/model/element~Element|Array.} blocks The list of selected blocks. * @param {Object} [options] - * TODO: Looks like expand in all directions is only used here, no need for forward or backward. * @param {Boolean} [options.withNested=true] Whether should include nested list items. * @returns {Array.} */ @@ -170,21 +169,15 @@ export function expandListBlocksToCompleteItems( blocks, options = {} ) { blocks = toArray( blocks ); const higherIndent = options.withNested !== false; - const expandForward = options.direction != 'backward'; - const expandBackward = options.direction != 'forward'; const allBlocks = new Set(); for ( const block of blocks ) { - if ( expandBackward ) { - for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'backward' } ) ) { - allBlocks.add( itemBlock ); - } + for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'backward' } ) ) { + allBlocks.add( itemBlock ); } - if ( expandForward ) { - for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'forward' } ) ) { - allBlocks.add( itemBlock ); - } + for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'forward' } ) ) { + allBlocks.add( itemBlock ); } } @@ -245,15 +238,13 @@ export function mergeListItemBefore( listBlock, parentBlock, writer ) { * @param {module:engine/model/writer~Writer} writer The model writer. * @param {Object} [options] * @param {Boolean} [options.expand=false] Whether should expand the list of blocks to include complete list items. - * TODO get rid of 'forward', looks like it is not used anywhere. - * @param {Number} [options.indentBy=1] TODO - * (all blocks of given list items). + * @param {Number} [options.indentBy=1] The number of levels the indentation should change (could be negative). */ export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { blocks = toArray( blocks ); // Expand the selected blocks to contain the whole list items. - const allBlocks = expand ? expandListBlocksToCompleteItems( blocks, { direction: expand == true ? 'both' : expand } ) : blocks; + const allBlocks = expand ? expandListBlocksToCompleteItems( blocks ) : blocks; for ( const block of allBlocks ) { const blockIndent = block.getAttribute( 'listIndent' ) + indentBy; @@ -271,24 +262,21 @@ export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { } /** - * TODO - * Decreases indentation of given list blocks. + * Decreases indentation of given list of blocks. If the indentation of some blocks matches the indentation + * of surrounding blocks, they get merged together. * * @protected * @param {module:engine/model/element~Element|Iterable.} blocks The block or iterable of blocks. * @param {module:engine/model/writer~Writer} writer The model writer. - * @param {Object} [options] - * @param {Boolean} [options.expand=false] Whether should expand the list of blocks to include complete list items - * (all blocks of given list items). */ -export function outdentBlocksWithMerge( blocks, writer, { expand } = {} ) { +export function outdentBlocksWithMerge( blocks, writer ) { blocks = toArray( blocks ); // Expand the selected blocks to contain the whole list items. - const allBlocks = expand ? expandListBlocksToCompleteItems( blocks ) : blocks; + const allBlocks = expandListBlocksToCompleteItems( blocks ); const visited = new Set(); - const referenceIndex = Math.min( ...allBlocks.map( block => block.getAttribute( 'listIndent' ) ) ); + const referenceIndent = Math.min( ...allBlocks.map( block => block.getAttribute( 'listIndent' ) ) ); const parentBlocks = new Map(); // Collect parent blocks before the list structure gets altered. @@ -312,7 +300,7 @@ export function outdentBlocksWithMerge( blocks, writer, { expand } = {} ) { } // Merge with parent list item while outdenting and indent matches reference indent. - if ( block.getAttribute( 'listIndent' ) == referenceIndex ) { + if ( block.getAttribute( 'listIndent' ) == referenceIndent ) { const mergedBlocks = mergeListItemIfNotLast( block, parentBlocks.get( block ), writer ); // All list item blocks are updated while merging so add those to visited set. diff --git a/packages/ckeditor5-list/tests/documentlist/utils/model.js b/packages/ckeditor5-list/tests/documentlist/utils/model.js index 56ae604398a..61eef020816 100644 --- a/packages/ckeditor5-list/tests/documentlist/utils/model.js +++ b/packages/ckeditor5-list/tests/documentlist/utils/model.js @@ -1319,7 +1319,7 @@ describe( 'DocumentList - utils - model', () => { let changedBlocks; model.change( writer => { - changedBlocks = outdentBlocksWithMerge( blocks, writer, { expand: true } ); + changedBlocks = outdentBlocksWithMerge( blocks, writer ); } ); expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ @@ -1353,7 +1353,7 @@ describe( 'DocumentList - utils - model', () => { let changedBlocks; model.change( writer => { - changedBlocks = outdentBlocksWithMerge( blocks, writer, { expand: true } ); + changedBlocks = outdentBlocksWithMerge( blocks, writer ); } ); expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ @@ -1387,7 +1387,7 @@ describe( 'DocumentList - utils - model', () => { let changedBlocks; model.change( writer => { - changedBlocks = outdentBlocksWithMerge( blocks, writer, { expand: true } ); + changedBlocks = outdentBlocksWithMerge( blocks, writer ); } ); expect( stringifyModel( fragment ) ).to.equalMarkup( modelList( [ From 1765012ad1ef930aa15c2615b2eb4fdb2893bca6 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 13:38:10 +0100 Subject: [PATCH 35/44] Tests: Improved the document list mocking test. --- .../ckeditor5-list/tests/manual/listmocking.js | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/packages/ckeditor5-list/tests/manual/listmocking.js b/packages/ckeditor5-list/tests/manual/listmocking.js index 8b8e741e74f..cdd99ac481b 100644 --- a/packages/ckeditor5-list/tests/manual/listmocking.js +++ b/packages/ckeditor5-list/tests/manual/listmocking.js @@ -39,15 +39,18 @@ ClassicEditor allowAttributesOf: '$container' } ); - editor.conversion.for( 'upcast' ).elementToElement( { model: 'blockWidget', view: 'blockwidget' } ); - - editor.conversion.for( 'downcast' ).elementToElement( { + editor.conversion.for( 'editingDowncast' ).elementToElement( { model: 'blockWidget', view: ( modelItem, { writer } ) => { return toWidget( writer.createContainerElement( 'blockwidget', { class: 'block-widget' } ), writer ); } } ); + editor.conversion.for( 'dataDowncast' ).elementToElement( { + model: 'blockWidget', + view: ( modelItem, { writer } ) => writer.createContainerElement( 'blockwidget', { class: 'block-widget' } ) + } ); + editor.model.schema.register( 'inlineWidget', { isObject: true, isInline: true, @@ -55,14 +58,18 @@ ClassicEditor allowAttributesOf: '$text' } ); - // The view element has no children. - editor.conversion.for( 'downcast' ).elementToElement( { + editor.conversion.for( 'editingDowncast' ).elementToElement( { model: 'inlineWidget', view: ( modelItem, { writer } ) => toWidget( writer.createContainerElement( 'inlinewidget', { class: 'inline-widget' } ), writer, { label: 'inline widget' } ) } ); + editor.conversion.for( 'dataDowncast' ).elementToElement( { + model: 'inlineWidget', + view: ( modelItem, { writer } ) => writer.createContainerElement( 'inlinewidget', { class: 'inline-widget' } ) + } ); + const model = 'A\n' + 'B\n' + 'C\n' + From fb02b68265647986b1a5735e56819819753bcd9b Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 13:46:59 +0100 Subject: [PATCH 36/44] Removed obsolete param from parse() document lists dev util. --- packages/ckeditor5-engine/src/dev-utils/model.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/ckeditor5-engine/src/dev-utils/model.js b/packages/ckeditor5-engine/src/dev-utils/model.js index 402888222c2..07eb843c9b2 100644 --- a/packages/ckeditor5-engine/src/dev-utils/model.js +++ b/packages/ckeditor5-engine/src/dev-utils/model.js @@ -304,7 +304,6 @@ export function stringify( node, selectionOrPositionOrRange = null, markers = nu * @param {Object} [options={}] Additional configuration. * @param {Array} [options.selectionAttributes] A list of attributes which will be passed to the selection. * @param {Boolean} [options.lastRangeBackward=false] If set to `true`, the last range will be added as backward. - * @param {Boolean} [options.wrapSingleElement=false] If set to `true`, single model elements will be wrapped in DocumentFragment. * @param {module:engine/model/schema~SchemaContextDefinition} [options.context='$root'] The conversion context. * If not provided, the default `'$root'` will be used. * @returns {module:engine/model/element~Element|module:engine/model/text~Text| @@ -352,7 +351,7 @@ export function parse( data, schema, options = {} ) { mapper.bindElements( model, viewDocumentFragment.root ); // If root DocumentFragment contains only one element - return that element. - if ( model.childCount == 1 && !options.wrapSingleElement ) { + if ( model.childCount == 1 ) { model = model.getChild( 0 ); } From 635ddbfa35817c7aae0642d9f186a3337c576efb Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 14:04:17 +0100 Subject: [PATCH 37/44] Code refactoring. --- .../src/documentlist/documentlistediting.js | 5 +++-- .../documentlist/documentlistmergecommand.js | 22 ++----------------- .../src/documentlist/utils/model.js | 22 +++++++++++++++++++ 3 files changed, 27 insertions(+), 22 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index ed87cd63e29..46e94ba7db9 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -14,7 +14,7 @@ import { CKEditorError } from 'ckeditor5/src/utils'; import DocumentListIndentCommand from './documentlistindentcommand'; import DocumentListCommand from './documentlistcommand'; -import DocumentListMergeCommand, { getSelectedBlockObject } from './documentlistmergecommand'; +import DocumentListMergeCommand from './documentlistmergecommand'; import DocumentListSplitCommand from './documentlistsplitcommand'; import { listItemDowncastConverter, @@ -33,7 +33,8 @@ import { getAllListItemBlocks, isFirstBlockOfListItem, isLastBlockOfListItem, - isSingleListItem + isSingleListItem, + getSelectedBlockObject } from './utils/model'; import ListWalker, { iterateSiblingListBlocks } from './utils/listwalker'; diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 646ba1f9895..43dc2173b39 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -14,7 +14,8 @@ import { sortBlocks, isFirstBlockOfListItem, mergeListItemBefore, - isSingleListItem + isSingleListItem, + getSelectedBlockObject } from './utils/model'; import ListWalker from './utils/listwalker'; @@ -232,22 +233,3 @@ export default class DocumentListMergeCommand extends Command { return { firstElement, lastElement }; } } - -// Returns a selected block object. If a selected object is inline or when there is no selected -// object, `null` is returned. -// -// @param {module:engine/model/model~Model} model -// @returns {module:engine/model/element~Element|null} -export function getSelectedBlockObject( model ) { - const selectedElement = model.document.selection.getSelectedElement(); - - if ( !selectedElement ) { - return null; - } - - if ( model.schema.isObject( selectedElement ) && model.schema.isBlock( selectedElement ) ) { - return selectedElement; - } - - return null; -} diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index b37ee0f1c54..36ee1ed1017 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -470,6 +470,28 @@ export function sortBlocks( blocks ) { .sort( ( a, b ) => a.index - b.index ); } +/** + * Returns a selected block object. If a selected object is inline or when there is no selected + * object, `null` is returned. + * + * @protected + * @param {module:engine/model/model~Model} model The instance of editor model. + * @returns {module:engine/model/element~Element|null} Selected block object or `null`. + */ +export function getSelectedBlockObject( model ) { + const selectedElement = model.document.selection.getSelectedElement(); + + if ( !selectedElement ) { + return null; + } + + if ( model.schema.isObject( selectedElement ) && model.schema.isBlock( selectedElement ) ) { + return selectedElement; + } + + return null; +} + // Merges a given block to the given parent block if parent is a list item and there is no more blocks in the same item. function mergeListItemIfNotLast( block, parentBlock, writer ) { const parentItemBlocks = getListItemBlocks( parentBlock, { direction: 'forward' } ); From f6a19d79170e72856a60f8dee5cd5fd2b8bea157 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 14:14:40 +0100 Subject: [PATCH 38/44] Made it possible to pass an element instance to the stringifyList() helper. --- .../tests/documentlist/_utils-tests/utils.js | 12 ++++-------- .../tests/documentlist/_utils/utils.js | 14 ++++++++++---- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js index 7445053e595..8bbce0a3359 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils-tests/utils.js @@ -542,8 +542,7 @@ describe( 'stringifyList()', () => { it( 'single list item', () => { const input = parseModel( 'a', - model.schema, - { wrapSingleElement: true } + model.schema ); expect( stringifyList( input ) ).to.equalMarkup( [ @@ -554,8 +553,7 @@ describe( 'stringifyList()', () => { it( 'empty list item', () => { const input = parseModel( '', - model.schema, - { wrapSingleElement: true } + model.schema ); expect( stringifyList( input ) ).to.equalMarkup( [ @@ -702,8 +700,7 @@ describe( 'stringifyList()', () => { it( 'single list item', () => { const input = parseModel( 'a', - model.schema, - { wrapSingleElement: true } + model.schema ); expect( stringifyList( input ) ).to.equal( [ @@ -714,8 +711,7 @@ describe( 'stringifyList()', () => { it( 'empty list item', () => { const input = parseModel( '', - model.schema, - { wrapSingleElement: true } + model.schema ); expect( stringifyList( input ) ).to.equal( [ diff --git a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js index 1aea32dbcba..5ee22bdb2fa 100644 --- a/packages/ckeditor5-list/tests/documentlist/_utils/utils.js +++ b/packages/ckeditor5-list/tests/documentlist/_utils/utils.js @@ -4,6 +4,7 @@ */ import Model from '@ckeditor/ckeditor5-engine/src/model/model'; +import DocumentFragment from '@ckeditor/ckeditor5-engine/src/model/documentfragment'; import { getData as getModelData, parse as parseModel, stringify as stringifyModel } from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; import { getData as getViewData } from '@ckeditor/ckeditor5-engine/src/dev-utils/view'; import ListWalker from '../../../src/documentlist/utils/listwalker'; @@ -274,17 +275,22 @@ export function modelList( lines ) { } /** - * Returns document list pseudo markdown notation for a given document fragment. + * Returns document list pseudo markdown notation for a given document fragment or element. * - * @param {module:engine/model/documentfragment~DocumentFragment} fragment The document fragment to stringify to pseudo markdown notation. + * @param {module:engine/model/documentfragment~DocumentFragment|module:engine/model/element~Element} fragmentOrElement The document + * fragment or element to stringify to pseudo markdown notation. * @returns {String} */ -export function stringifyList( fragment ) { +export function stringifyList( fragmentOrElement ) { const model = new Model(); const lines = []; + if ( fragmentOrElement.is( 'element' ) ) { + fragmentOrElement = new DocumentFragment( [ fragmentOrElement ] ); + } + model.change( writer => { - for ( let node = fragment.getChild( 0 ); node; node = node.nextSibling ) { + for ( let node = fragmentOrElement.getChild( 0 ); node; node = node.nextSibling ) { let pad = ''; if ( node.hasAttribute( 'listItemId' ) ) { From 15a2bf9334df912c4ffecb811058b3c44dc60a30 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 14:23:21 +0100 Subject: [PATCH 39/44] Internal: Fixed license headers. --- .../ckeditor5-list/src/documentlist/documentlistmergecommand.js | 2 +- .../tests/documentlist/documentlistmergecommand.js | 2 +- .../ckeditor5-list/tests/documentlist/integrations/clipboard.js | 2 +- .../ckeditor5-list/tests/documentlist/integrations/delete.js | 2 +- .../ckeditor5-list/tests/documentlist/integrations/enter.js | 2 +- packages/ckeditor5-list/theme/documentlist.css | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 43dc2173b39..8159ce6d9b1 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -1,5 +1,5 @@ /** - * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved. * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js index ea9ebf66adc..a7767693201 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js @@ -1,5 +1,5 @@ /** - * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved. * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js b/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js index f5c1266297b..6f9118a810b 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js @@ -1,5 +1,5 @@ /** - * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved. * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 8859525a524..24974498fe1 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -1,5 +1,5 @@ /** - * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved. * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/enter.js b/packages/ckeditor5-list/tests/documentlist/integrations/enter.js index 96c0fb45668..e21b937a6b1 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/enter.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/enter.js @@ -1,5 +1,5 @@ /** - * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved. * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ diff --git a/packages/ckeditor5-list/theme/documentlist.css b/packages/ckeditor5-list/theme/documentlist.css index 860bcdd0748..e156479eb22 100644 --- a/packages/ckeditor5-list/theme/documentlist.css +++ b/packages/ckeditor5-list/theme/documentlist.css @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved. + * Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved. * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license */ From 2f096f0b80f1fd8377ef42449441b13a1ae11385 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 14:32:01 +0100 Subject: [PATCH 40/44] Docs. --- .../src/documentlist/documentlistmergecommand.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index 8159ce6d9b1..b60dee9abd2 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -209,12 +209,12 @@ export default class DocumentListMergeCommand extends Command { if ( isFirstBlock && !shouldMergeOnBlocksContentLevel ) { // For the "c" as an anchorElement: - // * a - // * b + // * a + // * b // * [c] <-- this block should be merged with "a" // It should find "a" element to merge with: - // * a - // * b + // * a + // * b // c firstElement = ListWalker.first( positionParent, { sameIndent: true, lowerIndent: true } ); } else { From 03a59d9b137b488dc821a1130b6dedde634bb6d9 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 14:48:41 +0100 Subject: [PATCH 41/44] Code refactoring in tests --- .../documentlist/documentlistmergecommand.js | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js index a7767693201..dc57cbc545d 100644 --- a/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/tests/documentlist/documentlistmergecommand.js @@ -8,7 +8,6 @@ import DocumentListMergeCommand from '../../src/documentlist/documentlistmergeco import Editor from '@ckeditor/ckeditor5-core/src/editor/editor'; import Model from '@ckeditor/ckeditor5-engine/src/model/model'; -import { toWidget } from '@ckeditor/ckeditor5-widget/src/utils'; import testUtils from '@ckeditor/ckeditor5-core/tests/_utils/utils'; import { setData, getData } from '@ckeditor/ckeditor5-engine/src/dev-utils/model'; @@ -37,27 +36,12 @@ describe( 'DocumentListMergeCommand', () => { allowAttributesOf: '$container' } ); - editor.conversion.for( 'downcast' ).elementToElement( { - model: 'blockWidget', - view: ( modelItem, { writer } ) => { - return toWidget( writer.createContainerElement( 'blockwidget', { class: 'block-widget' } ), writer ); - } - } ); - editor.model.schema.register( 'inlineWidget', { isObject: true, isInline: true, allowWhere: '$text', allowAttributesOf: '$text' } ); - - // The view element has no children. - editor.conversion.for( 'downcast' ).elementToElement( { - model: 'inlineWidget', - view: ( modelItem, { writer } ) => toWidget( - writer.createContainerElement( 'inlinewidget', { class: 'inline-widget' } ), writer, { label: 'inline widget' } - ) - } ); } ); afterEach( () => { From 242be473db0925459fb7c2010035ec95261e1af6 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 15:01:20 +0100 Subject: [PATCH 42/44] Code refactoring in tests --- .../tests/documentlist/integrations/clipboard.js | 9 --------- .../tests/documentlist/integrations/delete.js | 2 -- .../tests/documentlist/integrations/enter.js | 9 --------- 3 files changed, 20 deletions(-) diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js b/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js index 6f9118a810b..219d0998c04 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/clipboard.js @@ -47,15 +47,6 @@ describe( 'DocumentListEditing integrations: clipboard copy & paste', () => { allowAttributes: 'foo' } ); - model.schema.register( 'nonListable', { - allowWhere: '$block', - allowContentOf: '$block', - inheritTypesFrom: '$block', - allowAttributes: 'foo' - } ); - - editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); - // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); stubUid(); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js index 24974498fe1..3bfb4966519 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/delete.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/delete.js @@ -81,8 +81,6 @@ describe( 'DocumentListEditing integrations: backspace & delete', () => { ) } ); - // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. - sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); stubUid(); eventInfo = new BubblingEventInfo( view.document, 'delete' ); diff --git a/packages/ckeditor5-list/tests/documentlist/integrations/enter.js b/packages/ckeditor5-list/tests/documentlist/integrations/enter.js index e21b937a6b1..3b7eb86104f 100644 --- a/packages/ckeditor5-list/tests/documentlist/integrations/enter.js +++ b/packages/ckeditor5-list/tests/documentlist/integrations/enter.js @@ -53,15 +53,6 @@ describe( 'DocumentListEditing integrations: enter key', () => { allowAttributes: 'foo' } ); - model.schema.register( 'nonListable', { - allowWhere: '$block', - allowContentOf: '$block', - inheritTypesFrom: '$block', - allowAttributes: 'foo' - } ); - - editor.conversion.elementToElement( { model: 'nonListable', view: 'div' } ); - // Stub `view.scrollToTheSelection` as it will fail on VirtualTestEditor without DOM. sinon.stub( view, 'scrollToTheSelection' ).callsFake( () => { } ); stubUid(); From d30f8e517295642552a07001fa3e692684edf63d Mon Sep 17 00:00:00 2001 From: Kuba Niegowski <1232187+niegowski@users.noreply.github.com> Date: Wed, 2 Feb 2022 15:12:22 +0100 Subject: [PATCH 43/44] Apply suggestions from code review. --- .../src/documentlist/documentlistediting.js | 2 +- .../src/documentlist/documentlistindentcommand.js | 2 +- .../src/documentlist/documentlistmergecommand.js | 2 +- .../ckeditor5-list/src/documentlist/utils/model.js | 12 +++--------- 4 files changed, 6 insertions(+), 12 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/documentlistediting.js b/packages/ckeditor5-list/src/documentlist/documentlistediting.js index 46e94ba7db9..b7273691e34 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistediting.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistediting.js @@ -461,7 +461,7 @@ function createModelIndentPasteFixer( model ) { }; } -// Decided whether the merge should be accompanied by the model's `deleteContent()`, for instance to get rid of the inline +// Decides whether the merge should be accompanied by the model's `deleteContent()`, for instance, to get rid of the inline // content in the selection or take advantage of the heuristics in `deleteContent()` that helps convert lists into paragraphs // in certain cases. // diff --git a/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js b/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js index 125e298d2de..f2788b2d7c2 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistindentcommand.js @@ -82,7 +82,7 @@ export default class DocumentListIndentCommand extends Command { if ( this._direction == 'forward' ) { changedBlocks.push( ...indentBlocks( blocks, writer, { expand: true } ) ); } else { - changedBlocks.push( ...outdentBlocksWithMerge( blocks, writer, { expand: true } ) ); + changedBlocks.push( ...outdentBlocksWithMerge( blocks, writer ) ); } } diff --git a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js index b60dee9abd2..76ece299ab9 100644 --- a/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js +++ b/packages/ckeditor5-list/src/documentlist/documentlistmergecommand.js @@ -191,7 +191,7 @@ export default class DocumentListMergeCommand extends Command { * @param {module:engine/model/selection~Selection} selection The selection the merge is executed for. * @param {Boolean} shouldMergeOnBlocksContentLevel When `true`, merge is performed together with * {@link module:engine/model/model~Model#deleteContent} to remove the inline content within the selection. - * @returns {Object.} elements + * @returns {Object} elements * @returns {module:engine/model/element~Element} elements.firstElement * @returns {module:engine/model/element~Element} elements.lastElement */ diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 36ee1ed1017..2e2052d06ee 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -172,11 +172,7 @@ export function expandListBlocksToCompleteItems( blocks, options = {} ) { const allBlocks = new Set(); for ( const block of blocks ) { - for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'backward' } ) ) { - allBlocks.add( itemBlock ); - } - - for ( const itemBlock of getListItemBlocks( block, { higherIndent, direction: 'forward' } ) ) { + for ( const itemBlock of getAllListItemBlocks( block, { higherIndent } ) ) { allBlocks.add( itemBlock ); } } @@ -251,11 +247,9 @@ export function indentBlocks( blocks, writer, { expand, indentBy = 1 } = {} ) { if ( blockIndent < 0 ) { removeListAttributes( block, writer ); - - continue; + } else { + writer.setAttribute( 'listIndent', blockIndent, block ); } - - writer.setAttribute( 'listIndent', blockIndent, block ); } return allBlocks; From b9cedf5647906e9ea95b0a7eba6c8c8dbc3c24e7 Mon Sep 17 00:00:00 2001 From: Aleksander Nowodzinski Date: Wed, 2 Feb 2022 15:20:13 +0100 Subject: [PATCH 44/44] Code refactoring. --- packages/ckeditor5-list/src/documentlist/utils/model.js | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/packages/ckeditor5-list/src/documentlist/utils/model.js b/packages/ckeditor5-list/src/documentlist/utils/model.js index 2e2052d06ee..7339ce5c2b9 100644 --- a/packages/ckeditor5-list/src/documentlist/utils/model.js +++ b/packages/ckeditor5-list/src/documentlist/utils/model.js @@ -439,13 +439,8 @@ export function outdentFollowingItems( lastBlock, writer ) { // Note, that if we just changed the current relative indent, the newIndent will be equal to 0. const newIndent = indent - currentIndent; - // Save the entry in changes array. We do not apply it at the moment, because we will need to - // reverse the changes so the last item is changed first. - // This is to keep model in correct state all the time. - if ( node.getAttribute( 'listIndent' ) != newIndent ) { - writer.setAttribute( 'listIndent', newIndent, node ); - changedBlocks.push( node ); - } + writer.setAttribute( 'listIndent', newIndent, node ); + changedBlocks.push( node ); } return changedBlocks;