8
0
Просмотр исходного кода

Aligned test with engine changes.

Oskar Wróbel 8 лет назад
Родитель
Сommit
3a3d57c9db

+ 0 - 1
packages/ckeditor5-paragraph/src/paragraph.js

@@ -216,7 +216,6 @@ function autoparagraphItems( evt, data, consumable, conversionApi ) {
 		if ( isParagraphable( child, data.context, conversionApi.schema, isParagraphLike ) ) {
 			// If there is no wrapping `paragraph` element, create it.
 			if ( !autoParagraph ) {
-				conversionApi.writer.insertElement( 'paragraph', data.output, child.index );
 				autoParagraph = conversionApi.writer.createElement( 'paragraph' );
 				conversionApi.writer.insert( autoParagraph, data.output, child.index );
 			}

+ 1 - 1
packages/ckeditor5-paragraph/src/paragraphcommand.js

@@ -52,7 +52,7 @@ export default class ParagraphCommand extends Command {
 		const model = this.editor.model;
 		const document = model.document;
 
-		model.enqueueChange( writer => {
+		model.change( writer => {
 			const blocks = ( options.selection || document.selection ).getSelectedBlocks();
 
 			for ( const block of blocks ) {

+ 22 - 25
packages/ckeditor5-paragraph/tests/paragraph-intergration.js

@@ -21,16 +21,15 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, Clipboard ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
 					const clipboard = editor.plugins.get( 'Clipboard' );
 
-					setModelData( doc, '<paragraph>[]</paragraph>' );
+					setModelData( editor.model, '<paragraph>[]</paragraph>' );
 
 					clipboard.fire( 'inputTransformation', {
 						content: parseView( '<h1>foo</h1><h2>bar</h2><p>bom</p>' )
 					} );
 
-					expect( getModelData( doc ) ).to.equal(
+					expect( getModelData( editor.model ) ).to.equal(
 						'<paragraph>foo</paragraph><paragraph>bar</paragraph><paragraph>bom[]</paragraph>'
 					);
 				} );
@@ -42,16 +41,15 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, Clipboard, HeadingEngine ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
 					const clipboard = editor.plugins.get( 'Clipboard' );
 
-					setModelData( doc, '<paragraph>[]</paragraph>' );
+					setModelData( editor.model, '<paragraph>[]</paragraph>' );
 
 					clipboard.fire( 'inputTransformation', {
 						content: parseView( '<h1>foo</h1><h2>bar</h2><p>bom</p>' )
 					} );
 
-					expect( getModelData( doc ) ).to.equal(
+					expect( getModelData( editor.model ) ).to.equal(
 						'<paragraph>foo</paragraph><heading1>bar</heading1><paragraph>bom[]</paragraph>'
 					);
 				} );
@@ -62,16 +60,15 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, Clipboard ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
 					const clipboard = editor.plugins.get( 'Clipboard' );
 
-					setModelData( doc, '<paragraph>[]</paragraph>' );
+					setModelData( editor.model, '<paragraph>[]</paragraph>' );
 
 					clipboard.fire( 'inputTransformation', {
 						content: parseView( '<ul><li>foo</li><li>bar</li></ul>' )
 					} );
 
-					expect( getModelData( doc ) ).to.equal( '<paragraph>foo</paragraph><paragraph>bar[]</paragraph>' );
+					expect( getModelData( editor.model ) ).to.equal( '<paragraph>foo</paragraph><paragraph>bar[]</paragraph>' );
 				} );
 		} );
 
@@ -82,16 +79,15 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, Clipboard, HeadingEngine ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
 					const clipboard = editor.plugins.get( 'Clipboard' );
 
-					setModelData( doc, '<paragraph>[]</paragraph>' );
+					setModelData( editor.model, '<paragraph>[]</paragraph>' );
 
 					clipboard.fire( 'inputTransformation', {
 						content: parseView( '<ul><li>x</li><li><h2>foo</h2><h3>bar</h3><p>bom</p></li><li>x</li></ul>' )
 					} );
 
-					expect( getModelData( doc ) ).to.equal(
+					expect( getModelData( editor.model ) ).to.equal(
 						'<paragraph>x</paragraph>' +
 						'<heading1>foo</heading1><heading2>bar</heading2><paragraph>bom</paragraph>' +
 						'<paragraph>x[]</paragraph>'
@@ -105,16 +101,15 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, Clipboard ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
 					const clipboard = editor.plugins.get( 'Clipboard' );
 
-					setModelData( doc, '<paragraph>[]</paragraph>' );
+					setModelData( editor.model, '<paragraph>[]</paragraph>' );
 
 					clipboard.fire( 'inputTransformation', {
 						content: parseView( '<ul><li>a<ul><li>b</li><li>c</li></ul></li></ul>' )
 					} );
 
-					expect( getModelData( doc ) ).to.equal(
+					expect( getModelData( editor.model ) ).to.equal(
 						'<paragraph>a</paragraph>' +
 						'<paragraph>b</paragraph>' +
 						'<paragraph>c[]</paragraph>'
@@ -128,16 +123,15 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, Clipboard ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
 					const clipboard = editor.plugins.get( 'Clipboard' );
 
-					setModelData( doc, '<paragraph>[]</paragraph>' );
+					setModelData( editor.model, '<paragraph>[]</paragraph>' );
 
 					clipboard.fire( 'inputTransformation', {
 						content: parseView( '<ul><li><p>a</p>b</li></ul>' )
 					} );
 
-					expect( getModelData( doc ) ).to.equal(
+					expect( getModelData( editor.model ) ).to.equal(
 						'<paragraph>a</paragraph>' +
 						'<paragraph>b[]</paragraph>'
 					);
@@ -151,7 +145,7 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, UndoEngine ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
+					const doc = editor.model.document;
 					const root = doc.getRoot();
 
 					expect( editor.getData() ).to.equal( '<p>&nbsp;</p>' );
@@ -159,8 +153,8 @@ describe( 'Paragraph feature – integration', () => {
 
 					editor.setData( '<p>Foobar.</p>' );
 
-					doc.enqueueChanges( () => {
-						doc.batch().remove( root.getChild( 0 ) );
+					editor.model.change( writer => {
+						writer.remove( root.getChild( 0 ) );
 					} );
 
 					expect( editor.getData() ).to.equal( '<p>&nbsp;</p>' );
@@ -184,7 +178,7 @@ describe( 'Paragraph feature – integration', () => {
 				.create( { plugins: [ Paragraph, UndoEngine ] } )
 				.then( newEditor => {
 					const editor = newEditor;
-					const doc = editor.document;
+					const doc = editor.model.document;
 					const root = doc.getRoot();
 					const otherRoot = doc.createRoot( '$root', 'otherRoot' );
 					editor.editing.createRoot( 'div', 'otherRoot' );
@@ -192,9 +186,12 @@ describe( 'Paragraph feature – integration', () => {
 					editor.data.set( '<p>Foobar.</p>', 'main' );
 					editor.data.set( '<p>Foobar.</p>', 'otherRoot' );
 
-					doc.enqueueChanges( () => {
-						doc.batch().remove( root.getChild( 0 ) );
-						doc.batch().remove( otherRoot.getChild( 0 ) );
+					editor.model.change( writer => {
+						writer.remove( root.getChild( 0 ) );
+					} );
+
+					editor.model.change( writer => {
+						writer.remove( otherRoot.getChild( 0 ) );
 					} );
 
 					expect( editor.data.get( 'main' ) ).to.equal( '<p>&nbsp;</p>' );

+ 76 - 75
packages/ckeditor5-paragraph/tests/paragraph.js

@@ -21,16 +21,16 @@ import ModelText from '@ckeditor/ckeditor5-engine/src/model/text';
 import ModelRange from '@ckeditor/ckeditor5-engine/src/model/range';
 
 describe( 'Paragraph feature', () => {
-	let editor, doc, root, batch;
+	let model, editor, doc, root;
 
 	beforeEach( () => {
 		return VirtualTestEditor
 			.create( { plugins: [ Paragraph ] } )
 			.then( newEditor => {
 				editor = newEditor;
-				doc = editor.document;
+				model = editor.model;
+				doc = model.document;
 				root = doc.getRoot();
-				batch = doc.batch();
 			} );
 	} );
 
@@ -39,9 +39,9 @@ describe( 'Paragraph feature', () => {
 	} );
 
 	it( 'should set proper schema rules', () => {
-		expect( doc.schema.hasItem( 'paragraph' ) ).to.be.true;
-		expect( doc.schema.check( { name: 'paragraph', inside: '$root' } ) ).to.be.true;
-		expect( doc.schema.check( { name: '$inline', inside: 'paragraph' } ) ).to.be.true;
+		expect( model.schema.hasItem( 'paragraph' ) ).to.be.true;
+		expect( model.schema.check( { name: 'paragraph', inside: '$root' } ) ).to.be.true;
+		expect( model.schema.check( { name: '$inline', inside: 'paragraph' } ) ).to.be.true;
 	} );
 
 	it( 'should have a static paragraphLikeElements property', () => {
@@ -52,21 +52,21 @@ describe( 'Paragraph feature', () => {
 		it( 'should convert paragraph', () => {
 			editor.setData( '<p>foobar</p>' );
 
-			expect( getModelData( doc, { withoutSelection: true } ) ).to.equal( '<paragraph>foobar</paragraph>' );
+			expect( getModelData( model, { withoutSelection: true } ) ).to.equal( '<paragraph>foobar</paragraph>' );
 			expect( editor.getData() ).to.equal( '<p>foobar</p>' );
 		} );
 
 		it( 'should convert paragraph only', () => {
 			editor.setData( '<p>foo<b>baz</b>bar</p>' );
 
-			expect( getModelData( doc, { withoutSelection: true } ) ).to.equal( '<paragraph>foobazbar</paragraph>' );
+			expect( getModelData( model, { withoutSelection: true } ) ).to.equal( '<paragraph>foobazbar</paragraph>' );
 			expect( editor.getData() ).to.equal( '<p>foobazbar</p>' );
 		} );
 
 		it( 'should convert multiple paragraphs', () => {
 			editor.setData( '<p>foo</p><p>baz</p>' );
 
-			expect( getModelData( doc, { withoutSelection: true } ) ).to.equal( '<paragraph>foo</paragraph><paragraph>baz</paragraph>' );
+			expect( getModelData( model, { withoutSelection: true } ) ).to.equal( '<paragraph>foo</paragraph><paragraph>baz</paragraph>' );
 			expect( editor.getData() ).to.equal( '<p>foo</p><p>baz</p>' );
 		} );
 
@@ -74,71 +74,71 @@ describe( 'Paragraph feature', () => {
 			it( 'should autoparagraph text', () => {
 				editor.setData( 'foo' );
 
-				expect( getModelData( doc, { withoutSelection: true } ) ).to.equal( '<paragraph>foo</paragraph>' );
+				expect( getModelData( model, { withoutSelection: true } ) ).to.equal( '<paragraph>foo</paragraph>' );
 				expect( editor.getData() ).to.equal( '<p>foo</p>' );
 			} );
 
 			it( 'should autoparagraph any inline element', () => {
-				editor.document.schema.registerItem( 'span', '$inline' );
-				editor.document.schema.allow( { name: '$text', inside: '$inline' } );
+				editor.model.schema.registerItem( 'span', '$inline' );
+				editor.model.schema.allow( { name: '$text', inside: '$inline' } );
 
 				buildModelConverter().for( editor.editing.modelToView, editor.data.modelToView ).fromElement( 'span' ).toElement( 'span' );
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'span' ).toElement( 'span' );
 
 				editor.setData( '<span>foo</span>' );
 
-				expect( getModelData( doc, { withoutSelection: true } ) ).to.equal( '<paragraph><span>foo</span></paragraph>' );
+				expect( getModelData( model, { withoutSelection: true } ) ).to.equal( '<paragraph><span>foo</span></paragraph>' );
 				expect( editor.getData() ).to.equal( '<p><span>foo</span></p>' );
 			} );
 
 			it( 'should not autoparagraph text (in clipboard holder)', () => {
-				const modelFragment = editor.data.parse( 'foo', batch, '$clipboardHolder' );
+				const modelFragment = editor.data.parse( 'foo', '$clipboardHolder' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( 'foo' );
 			} );
 
 			it( 'should not autoparagraph text (in a context which does not allow paragraphs', () => {
-				doc.schema.registerItem( 'specialRoot' );
+				model.schema.registerItem( 'specialRoot' );
 
-				const modelFragment = editor.data.parse( 'foo', batch, 'specialRoot' );
+				const modelFragment = editor.data.parse( 'foo', 'specialRoot' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '' );
 			} );
 
 			it( 'should autoparagraph text next to allowed element', () => {
-				doc.schema.registerItem( 'heading1', '$block' );
+				model.schema.registerItem( 'heading1', '$block' );
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'h1' ).toElement( 'heading1' );
 
-				const modelFragment = editor.data.parse( '<h1>foo</h1>bar<p>bom</p>', batch );
+				const modelFragment = editor.data.parse( '<h1>foo</h1>bar<p>bom</p>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<heading1>foo</heading1><paragraph>bar</paragraph><paragraph>bom</paragraph>' );
 			} );
 
 			it( 'should autoparagraph 3 inline nodes into one paragraph', () => {
-				const modelFragment = editor.data.parse( 'foo<b>bar</b>bom', batch );
+				const modelFragment = editor.data.parse( 'foo<b>bar</b>bom' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>foobarbom</paragraph>' );
 			} );
 
 			it( 'should not autoparagraph 3 inline nodes (in clipboardHolder)', () => {
-				const modelFragment = editor.data.parse( 'foo<b>bar</b>bom', batch, '$clipboardHolder' );
+				const modelFragment = editor.data.parse( 'foo<b>bar</b>bom', '$clipboardHolder' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( 'foobarbom' );
 			} );
 
 			it( 'should autoparagraph text inside converted container', () => {
-				doc.schema.registerItem( 'div' );
-				doc.schema.allow( { name: 'div', inside: '$root' } );
-				doc.schema.allow( { name: 'paragraph', inside: 'div' } );
+				model.schema.registerItem( 'div' );
+				model.schema.allow( { name: 'div', inside: '$root' } );
+				model.schema.allow( { name: 'paragraph', inside: 'div' } );
 
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'div' ).toElement( 'div' );
 
-				const modelFragment = editor.data.parse( '<div>foo</div><div>bom<p>bim</p></div>', batch );
+				const modelFragment = editor.data.parse( '<div>foo</div><div>bom<p>bim</p></div>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal(
@@ -148,35 +148,35 @@ describe( 'Paragraph feature', () => {
 			} );
 
 			it( 'should autoparagraph text inside disallowed element next to allowed element', () => {
-				doc.schema.registerItem( 'heading1', '$block' );
+				model.schema.registerItem( 'heading1', '$block' );
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'h1' ).toElement( 'heading1' );
 
-				const modelFragment = editor.data.parse( '<div><h1>foo</h1>bar</div>', batch );
+				const modelFragment = editor.data.parse( '<div><h1>foo</h1>bar</div>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<heading1>foo</heading1><paragraph>bar</paragraph>' );
 			} );
 
 			it( 'should not autoparagraph text in disallowed element', () => {
-				doc.schema.registerItem( 'heading1', '$block' );
+				model.schema.registerItem( 'heading1', '$block' );
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'h1' ).toElement( 'heading1' );
 
-				const modelFragment = editor.data.parse( '<h1><b>foo</b>bar</h1>', batch );
+				const modelFragment = editor.data.parse( '<h1><b>foo</b>bar</h1>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<heading1>foobar</heading1>' );
 			} );
 
 			it( 'should not fail when text is not allowed in paragraph', () => {
-				doc.schema.disallow( { name: '$text', inside: [ '$root', 'paragraph' ] } );
+				model.schema.disallow( { name: '$text', inside: [ '$root', 'paragraph' ] } );
 
-				const modelFragment = editor.data.parse( 'foo', batch );
+				const modelFragment = editor.data.parse( 'foo' );
 
 				expect( stringifyModel( modelFragment ) ).to.equal( '' );
 			} );
 
 			it( 'creates normalized model', () => {
-				const modelFragment = editor.data.parse( 'foo<b>bar</b>bom', batch );
+				const modelFragment = editor.data.parse( 'foo<b>bar</b>bom' );
 
 				expect( modelFragment ).to.be.instanceof( ModelDocumentFragment );
 				expect( modelFragment.getChild( 0 ).childCount ).to.equal( 1 );
@@ -189,29 +189,29 @@ describe( 'Paragraph feature', () => {
 					consumable.consume( data.input, { name: true } );
 				}, { priority: 'highest' } );
 
-				const modelFragment = editor.data.parse( '<ul><li></li></ul>', batch );
+				const modelFragment = editor.data.parse( '<ul><li></li></ul>' );
 
 				expect( stringifyModel( modelFragment ) ).to.equal( '' );
 			} );
 
 			describe( 'should not strip attribute elements when autoparagraphing texts', () => {
 				beforeEach( () => {
-					doc.schema.allow( { name: '$inline', attributes: [ 'bold' ] } );
+					model.schema.allow( { name: '$inline', attributes: [ 'bold' ] } );
 					buildViewConverter().for( editor.data.viewToModel )
 						.fromElement( 'b' )
 						.toAttribute( 'bold', true );
 				} );
 
 				it( 'inside document fragment', () => {
-					const modelFragment = editor.data.parse( 'foo<b>bar</b>bom', batch );
+					const modelFragment = editor.data.parse( 'foo<b>bar</b>bom' );
 
 					expect( stringifyModel( modelFragment ) ).to.equal( '<paragraph>foo<$text bold="true">bar</$text>bom</paragraph>' );
 				} );
 
 				it( 'inside converted element', () => {
-					doc.schema.registerItem( 'blockquote' );
-					doc.schema.allow( { name: 'blockquote', inside: '$root' } );
-					doc.schema.allow( { name: '$block', inside: 'blockquote' } );
+					model.schema.registerItem( 'blockquote' );
+					model.schema.allow( { name: 'blockquote', inside: '$root' } );
+					model.schema.allow( { name: '$block', inside: 'blockquote' } );
 
 					buildModelConverter().for( editor.editing.modelToView, editor.data.modelToView )
 						.fromElement( 'blockquote' )
@@ -219,14 +219,14 @@ describe( 'Paragraph feature', () => {
 
 					buildViewConverter().for( editor.data.viewToModel ).fromElement( 'blockquote' ).toElement( 'blockquote' );
 
-					const modelFragment = editor.data.parse( '<blockquote>foo<b>bar</b>bom</blockquote>', batch );
+					const modelFragment = editor.data.parse( '<blockquote>foo<b>bar</b>bom</blockquote>' );
 
 					expect( stringifyModel( modelFragment ) )
 						.to.equal( '<blockquote><paragraph>foo<$text bold="true">bar</$text>bom</paragraph></blockquote>' );
 				} );
 
 				it( 'inside paragraph-like element', () => {
-					const modelFragment = editor.data.parse( '<h1>foo</h1><h2><b>bar</b>bom</h2>', batch );
+					const modelFragment = editor.data.parse( '<h1>foo</h1><h2><b>bar</b>bom</h2>' );
 
 					expect( stringifyModel( modelFragment ) )
 						.to.equal( '<paragraph>foo</paragraph><paragraph><$text bold="true">bar</$text>bom</paragraph>' );
@@ -236,49 +236,49 @@ describe( 'Paragraph feature', () => {
 
 		describe( 'generic block converter (paragraph-like element handling)', () => {
 			it( 'should convert h1+h2', () => {
-				const modelFragment = editor.data.parse( '<h1>foo</h1><h2>bar</h2>', batch );
+				const modelFragment = editor.data.parse( '<h1>foo</h1><h2>bar</h2>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>foo</paragraph><paragraph>bar</paragraph>' );
 			} );
 
 			it( 'should convert h1+h2 (in clipboard holder)', () => {
-				const modelFragment = editor.data.parse( '<h1>foo</h1><h2>bar</h2>', batch, '$clipboardHolder' );
+				const modelFragment = editor.data.parse( '<h1>foo</h1><h2>bar</h2>', '$clipboardHolder' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>foo</paragraph><paragraph>bar</paragraph>' );
 			} );
 
 			it( 'should not convert h1+h2 (in a context which does not allow paragraphs)', () => {
-				doc.schema.registerItem( 'div' );
-				doc.schema.registerItem( 'specialRoot' );
-				doc.schema.allow( { name: 'div', inside: 'specialRoot' } );
-				doc.schema.allow( { name: '$text', inside: 'div' } );
+				model.schema.registerItem( 'div' );
+				model.schema.registerItem( 'specialRoot' );
+				model.schema.allow( { name: 'div', inside: 'specialRoot' } );
+				model.schema.allow( { name: '$text', inside: 'div' } );
 
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'div' ).toElement( 'div' );
 
-				const modelFragment = editor.data.parse( '<h1>foo</h1><h2>bar</h2><div>bom</div>', batch, 'specialRoot' );
+				const modelFragment = editor.data.parse( '<h1>foo</h1><h2>bar</h2><div>bom</div>', 'specialRoot' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<div>bom</div>' );
 			} );
 
 			it( 'should convert ul,ol>li', () => {
-				const modelFragment = editor.data.parse( '<ul><li>a</li><li>b</li></ul><ol><li>c</li></ol>', batch );
+				const modelFragment = editor.data.parse( '<ul><li>a</li><li>b</li></ul><ol><li>c</li></ol>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>a</paragraph><paragraph>b</paragraph><paragraph>c</paragraph>' );
 			} );
 
 			it( 'should convert ul,ol>li (in clipboard holder)', () => {
-				const modelFragment = editor.data.parse( '<ul><li>a</li><li>b</li></ul><ol><li>c</li></ol>', batch, '$clipboardHolder' );
+				const modelFragment = editor.data.parse( '<ul><li>a</li><li>b</li></ul><ol><li>c</li></ol>', '$clipboardHolder' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>a</paragraph><paragraph>b</paragraph><paragraph>c</paragraph>' );
 			} );
 
 			it( 'should convert ul>li>ul>li+li', () => {
-				const modelFragment = editor.data.parse( '<ul><li>a<ul><li>b</li><li>c</li></ul></li></ul>', batch );
+				const modelFragment = editor.data.parse( '<ul><li>a<ul><li>b</li><li>c</li></ul></li></ul>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>a</paragraph><paragraph>b</paragraph><paragraph>c</paragraph>' );
@@ -287,14 +287,14 @@ describe( 'Paragraph feature', () => {
 			// "b" is not autoparagraphed because clipboard holder allows text nodes.
 			// There's a similar integrational test what's going to happen when pasting in paragraph-integration.js.
 			it( 'should convert ul>li>ul>li+li (in clipboard holder)', () => {
-				const modelFragment = editor.data.parse( '<ul><li>a<ul><li>b</li><li>c</li></ul></li></ul>', batch, '$clipboardHolder' );
+				const modelFragment = editor.data.parse( '<ul><li>a<ul><li>b</li><li>c</li></ul></li></ul>', '$clipboardHolder' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>a</paragraph><paragraph>b</paragraph><paragraph>c</paragraph>' );
 			} );
 
 			it( 'should convert ul>li>p,text', () => {
-				const modelFragment = editor.data.parse( '<ul><li><p>a</p>b</li></ul>', batch );
+				const modelFragment = editor.data.parse( '<ul><li><p>a</p>b</li></ul>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>a</paragraph><paragraph>b</paragraph>' );
@@ -303,7 +303,7 @@ describe( 'Paragraph feature', () => {
 			// "b" is not autoparagraphed because clipboard holder allows text nodes.
 			// There's a similar integrational test what's going to happen when pasting in paragraph-integration.js.
 			it( 'should convert ul>li>p,text (in clipboard holder)', () => {
-				const modelFragment = editor.data.parse( '<ul><li><p>a</p>b</li></ul>', batch, '$clipboardHolder' );
+				const modelFragment = editor.data.parse( '<ul><li><p>a</p>b</li></ul>', '$clipboardHolder' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal( '<paragraph>a</paragraph><paragraph>b</paragraph>' );
@@ -311,8 +311,7 @@ describe( 'Paragraph feature', () => {
 
 			it( 'should convert td', () => {
 				const modelFragment = editor.data.parse(
-					'<table><tr><td>a</td><td>b</td></tr><tr><td>c</td><td>d</td></tr></table>',
-					batch
+					'<table><tr><td>a</td><td>b</td></tr><tr><td>c</td><td>d</td></tr></table>'
 				);
 
 				expect( stringifyModel( modelFragment ) )
@@ -322,7 +321,6 @@ describe( 'Paragraph feature', () => {
 			it( 'should convert td (in clipboardHolder)', () => {
 				const modelFragment = editor.data.parse(
 					'<table><tr><td>a</td><td>b</td></tr><tr><td>c</td><td>d</td></tr></table>',
-					batch,
 					'$clipboardHolder'
 				);
 
@@ -331,13 +329,13 @@ describe( 'Paragraph feature', () => {
 			} );
 
 			it( 'should convert li inside converted container', () => {
-				doc.schema.registerItem( 'div' );
-				doc.schema.allow( { name: 'div', inside: '$root' } );
-				doc.schema.allow( { name: 'paragraph', inside: 'div' } );
+				model.schema.registerItem( 'div' );
+				model.schema.allow( { name: 'div', inside: '$root' } );
+				model.schema.allow( { name: 'paragraph', inside: 'div' } );
 
 				buildViewConverter().for( editor.data.viewToModel ).fromElement( 'div' ).toElement( 'div' );
 
-				const modelFragment = editor.data.parse( '<div><ul><li>foo</li><li>bar</li></ul></div><div>bom<p>bim</p></div>', batch );
+				const modelFragment = editor.data.parse( '<div><ul><li>foo</li><li>bar</li></ul></div><div>bom<p>bim</p></div>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal(
@@ -347,7 +345,7 @@ describe( 'Paragraph feature', () => {
 			} );
 
 			it( 'should convert li inside disallowed container', () => {
-				const modelFragment = editor.data.parse( '<div><ul><li>foo</li><li>bar</li></ul></div><div>bom<p>bim</p></div>', batch );
+				const modelFragment = editor.data.parse( '<div><ul><li>foo</li><li>bar</li></ul></div><div>bom<p>bim</p></div>' );
 
 				expect( stringifyModel( modelFragment ) )
 					.to.equal(
@@ -357,7 +355,7 @@ describe( 'Paragraph feature', () => {
 			} );
 
 			it( 'creates normalized model', () => {
-				const modelFragment = editor.data.parse( '<h1><span>foo</span><span>bar</span>', batch );
+				const modelFragment = editor.data.parse( '<h1><span>foo</span><span>bar</span>' );
 
 				expect( stringifyModel( modelFragment ) ).to.equal( '<paragraph>foobar</paragraph>' );
 
@@ -370,7 +368,7 @@ describe( 'Paragraph feature', () => {
 
 	describe( 'editing pipeline conversion', () => {
 		it( 'should convert paragraph', () => {
-			setModelData( doc, '<paragraph>foo</paragraph><paragraph>bar</paragraph>' );
+			setModelData( model, '<paragraph>foo</paragraph><paragraph>bar</paragraph>' );
 
 			expect( getViewData( editor.editing.view, { withoutSelection: true } ) ).to.equal( '<p>foo</p><p>bar</p>' );
 		} );
@@ -380,7 +378,7 @@ describe( 'Paragraph feature', () => {
 		it( 'wraps text and place selection at the beginning of that paragraph', () => {
 			editor.setData( 'foo' );
 
-			expect( getModelData( doc ) ).to.equal( '<paragraph>[]foo</paragraph>' );
+			expect( getModelData( model ) ).to.equal( '<paragraph>[]foo</paragraph>' );
 		} );
 	} );
 
@@ -398,8 +396,8 @@ describe( 'Paragraph feature', () => {
 			// fix root if it is not needed.
 			expect( editor.getData() ).to.equal( '<p>Foobar</p>' );
 
-			doc.enqueueChanges( () => {
-				doc.batch().remove( ModelRange.createIn( root ) );
+			model.change( writer => {
+				writer.remove( ModelRange.createIn( root ) );
 			} );
 
 			expect( doc.getRoot().childCount ).to.equal( 1 );
@@ -408,7 +406,7 @@ describe( 'Paragraph feature', () => {
 
 		it( 'should not fix root if it got content during changesDone event', () => {
 			// "Autoheading feature".
-			doc.schema.registerItem( 'heading', '$block' );
+			model.schema.registerItem( 'heading', '$block' );
 
 			buildModelConverter().for( editor.editing.modelToView, editor.data.modelToView )
 				.fromElement( 'heading' )
@@ -418,14 +416,14 @@ describe( 'Paragraph feature', () => {
 				const root = doc.getRoot();
 
 				if ( root.isEmpty ) {
-					doc.enqueueChanges( () => {
-						doc.batch().insertElement( 'heading', root );
+					model.change( writer => {
+						writer.insertElement( 'heading', root );
 					} );
 				}
 			} );
 
-			doc.enqueueChanges( () => {
-				doc.batch().remove( ModelRange.createIn( root ) );
+			model.change( writer => {
+				writer.remove( ModelRange.createIn( root ) );
 			} );
 
 			expect( doc.getRoot().childCount ).to.equal( 1 );
@@ -433,19 +431,22 @@ describe( 'Paragraph feature', () => {
 		} );
 
 		it( 'should not fix root which does not allow paragraph', () => {
-			doc.schema.disallow( { name: 'paragraph', inside: '$root' } );
+			model.schema.disallow( { name: 'paragraph', inside: '$root' } );
 
-			doc.enqueueChanges( () => {
-				doc.batch().remove( ModelRange.createIn( root ) );
+			model.change( writer => {
+				writer.remove( ModelRange.createIn( root ) );
 			} );
+
 			expect( editor.getData() ).to.equal( '' );
+
+			editor.destroy();
 		} );
 
 		it( 'should not fix root if change was in transparent batch', () => {
 			editor.setData( '<p>Foobar</p>' );
 
-			doc.enqueueChanges( () => {
-				doc.batch( 'transparent' ).remove( ModelRange.createIn( root ) );
+			model.enqueueChange( 'transparent', writer => {
+				writer.remove( ModelRange.createIn( root ) );
 			} );
 
 			expect( editor.getData() ).to.equal( '' );

+ 52 - 47
packages/ckeditor5-paragraph/tests/paragraphcommand.js

@@ -10,13 +10,14 @@ import Range from '@ckeditor/ckeditor5-engine/src/model/range';
 import { setData, getData } from '@ckeditor/ckeditor5-engine/src/dev-utils/model';
 
 describe( 'ParagraphCommand', () => {
-	let editor, document, command, root, schema;
+	let editor, model, document, command, root, schema;
 
 	beforeEach( () => {
 		return ModelTestEditor.create().then( newEditor => {
 			editor = newEditor;
-			document = editor.document;
-			schema = document.schema;
+			model = editor.model;
+			document = model.document;
+			schema = model.schema;
 			command = new ParagraphCommand( editor );
 			root = document.getRoot();
 
@@ -36,41 +37,41 @@ describe( 'ParagraphCommand', () => {
 
 	describe( 'value', () => {
 		it( 'responds to changes in selection (collapsed selection)', () => {
-			setData( document, '<heading1>foo[]bar</heading1>' );
+			setData( model, '<heading1>foo[]bar</heading1>' );
 			expect( command.value ).to.be.false;
 
-			setData( document, '<paragraph>foo[]bar</paragraph>' );
+			setData( model, '<paragraph>foo[]bar</paragraph>' );
 			expect( command.value ).to.be.true;
 		} );
 
 		it( 'responds to changes in selection (non–collapsed selection)', () => {
-			setData( document, '<heading1>[foo]</heading1><paragraph>bar</paragraph>' );
+			setData( model, '<heading1>[foo]</heading1><paragraph>bar</paragraph>' );
 			expect( command.value ).to.be.false;
 
-			setData( document, '<heading1>[foo</heading1><paragraph>bar]</paragraph>' );
+			setData( model, '<heading1>[foo</heading1><paragraph>bar]</paragraph>' );
 			expect( command.value ).to.be.false;
 
-			setData( document, '<heading1>foo</heading1>[<paragraph>bar]</paragraph>' );
+			setData( model, '<heading1>foo</heading1>[<paragraph>bar]</paragraph>' );
 			expect( command.value ).to.be.true;
 
-			setData( document, '<heading1>foo</heading1><paragraph>[bar]</paragraph>' );
+			setData( model, '<heading1>foo</heading1><paragraph>[bar]</paragraph>' );
 			expect( command.value ).to.be.true;
 
-			setData( document, '<paragraph>[bar</paragraph><heading1>foo]</heading1>' );
+			setData( model, '<paragraph>[bar</paragraph><heading1>foo]</heading1>' );
 			expect( command.value ).to.be.true;
 		} );
 
 		it( 'has proper value when inside non-block element', () => {
-			setData( document, '<notBlock>[foo]</notBlock>' );
+			setData( model, '<notBlock>[foo]</notBlock>' );
 
 			expect( command.value ).to.be.false;
 		} );
 
 		it( 'has proper value when moved from block to element that is not a block', () => {
-			setData( document, '<paragraph>[foo]</paragraph><notBlock>foo</notBlock>' );
+			setData( model, '<paragraph>[foo]</paragraph><notBlock>foo</notBlock>' );
 			const element = document.getRoot().getChild( 1 );
 
-			document.enqueueChanges( () => {
+			model.change( () => {
 				document.selection.setRanges( [ Range.createIn( element ) ] );
 			} );
 
@@ -78,7 +79,7 @@ describe( 'ParagraphCommand', () => {
 		} );
 
 		it( 'should be refreshed after calling refresh()', () => {
-			setData( document, '<paragraph>[foo]</paragraph><notBlock>foo</notBlock>' );
+			setData( model, '<paragraph>[foo]</paragraph><notBlock>foo</notBlock>' );
 			const element = document.getRoot().getChild( 1 );
 
 			// Purposely not putting it in `document.enqueueChanges` to update command manually.
@@ -92,24 +93,24 @@ describe( 'ParagraphCommand', () => {
 
 	describe( 'execute()', () => {
 		it( 'should update value after execution', () => {
-			setData( document, '<heading1>[]</heading1>' );
+			setData( model, '<heading1>[]</heading1>' );
 			command.execute();
 
-			expect( getData( document ) ).to.equal( '<paragraph>[]</paragraph>' );
+			expect( getData( model ) ).to.equal( '<paragraph>[]</paragraph>' );
 			expect( command.value ).to.be.true;
 		} );
 
 		// https://github.com/ckeditor/ckeditor5-paragraph/issues/24
 		it( 'should not rename blocks which cannot become paragraphs', () => {
-			document.schema.registerItem( 'restricted' );
-			document.schema.allow( { name: 'restricted', inside: '$root' } );
-			document.schema.disallow( { name: 'paragraph', inside: 'restricted' } );
+			model.schema.registerItem( 'restricted' );
+			model.schema.allow( { name: 'restricted', inside: '$root' } );
+			model.schema.disallow( { name: 'paragraph', inside: 'restricted' } );
 
-			document.schema.registerItem( 'fooBlock', '$block' );
-			document.schema.allow( { name: 'fooBlock', inside: 'restricted' } );
+			model.schema.registerItem( 'fooBlock', '$block' );
+			model.schema.allow( { name: 'fooBlock', inside: 'restricted' } );
 
 			setData(
-				document,
+				model,
 				'<heading1>a[bc</heading1>' +
 				'<restricted><fooBlock></fooBlock></restricted>' +
 				'<heading1>de]f</heading1>'
@@ -117,7 +118,7 @@ describe( 'ParagraphCommand', () => {
 
 			command.execute();
 
-			expect( getData( document ) ).to.equal(
+			expect( getData( model ) ).to.equal(
 				'<paragraph>a[bc</paragraph>' +
 				'<restricted><fooBlock></fooBlock></restricted>' +
 				'<paragraph>de]f</paragraph>'
@@ -125,28 +126,32 @@ describe( 'ParagraphCommand', () => {
 		} );
 
 		it( 'should not rename blocks which already are pargraphs', () => {
-			const batch = editor.document.batch();
+			setData( model, '<paragraph>foo[</paragraph><heading1>bar]</heading1>' );
 
-			setData( document, '<paragraph>foo[</paragraph><heading1>bar]</heading1>' );
-			expect( batch.deltas.length ).to.equal( 0 );
+			model.change( writer => {
+				expect( writer.batch.deltas.length ).to.equal( 0 );
 
-			command.execute( { batch } );
-			expect( batch.deltas.length ).to.equal( 1 );
+				command.execute();
+
+				expect( writer.batch.deltas.length ).to.equal( 1 );
+			} );
 		} );
 
 		describe( 'custom options', () => {
-			it( 'should use provided batch', () => {
-				const batch = editor.document.batch();
+			it( 'should use parent batch', () => {
+				setData( model, '<heading1>foo[]bar</heading1>' );
+
+				model.change( writer => {
+					expect( writer.batch.deltas.length ).to.equal( 0 );
 
-				setData( document, '<heading1>foo[]bar</heading1>' );
-				expect( batch.deltas.length ).to.equal( 0 );
+					command.execute();
 
-				command.execute( { batch } );
-				expect( batch.deltas.length ).to.be.above( 0 );
+					expect( writer.batch.deltas.length ).to.above( 0 );
+				} );
 			} );
 
 			it( 'should use provided selection', () => {
-				setData( document, '<heading1>foo[]bar</heading1><heading1>baz</heading1><heading1>qux</heading1>' );
+				setData( model, '<heading1>foo[]bar</heading1><heading1>baz</heading1><heading1>qux</heading1>' );
 
 				const secondToLastHeading = root.getChild( 1 );
 				const lastHeading = root.getChild( 2 );
@@ -154,7 +159,7 @@ describe( 'ParagraphCommand', () => {
 				selection.addRange( Range.createFromParentsAndOffsets( secondToLastHeading, 0, lastHeading, 1 ) );
 
 				command.execute( { selection } );
-				expect( getData( document ) ).to.equal(
+				expect( getData( model ) ).to.equal(
 					'<heading1>foo[]bar</heading1><paragraph>baz</paragraph><paragraph>qux</paragraph>'
 				);
 			} );
@@ -162,20 +167,20 @@ describe( 'ParagraphCommand', () => {
 
 		describe( 'collapsed selection', () => {
 			it( 'does nothing when executed with already applied', () => {
-				setData( document, '<paragraph>foo[]bar</paragraph>' );
+				setData( model, '<paragraph>foo[]bar</paragraph>' );
 				command.execute();
 
-				expect( getData( document ) ).to.equal( '<paragraph>foo[]bar</paragraph>' );
+				expect( getData( model ) ).to.equal( '<paragraph>foo[]bar</paragraph>' );
 			} );
 
 			it( 'converts topmost blocks', () => {
 				schema.registerItem( 'inlineImage', '$inline' );
 				schema.allow( { name: '$text', inside: 'inlineImage' } );
 
-				setData( document, '<heading1><inlineImage>foo[]</inlineImage>bar</heading1>' );
+				setData( model, '<heading1><inlineImage>foo[]</inlineImage>bar</heading1>' );
 				command.execute();
 
-				expect( getData( document ) ).to.equal( '<paragraph><inlineImage>foo[]</inlineImage>bar</paragraph>' );
+				expect( getData( model ) ).to.equal( '<paragraph><inlineImage>foo[]</inlineImage>bar</paragraph>' );
 			} );
 		} );
 
@@ -183,10 +188,10 @@ describe( 'ParagraphCommand', () => {
 			it( 'converts all elements where selection is applied', () => {
 				schema.registerItem( 'heading2', '$block' );
 
-				setData( document, '<heading1>foo[</heading1><heading2>bar</heading2><heading2>baz]</heading2>' );
+				setData( model, '<heading1>foo[</heading1><heading2>bar</heading2><heading2>baz]</heading2>' );
 
 				command.execute();
-				expect( getData( document ) ).to.equal(
+				expect( getData( model ) ).to.equal(
 					'<paragraph>foo[</paragraph><paragraph>bar</paragraph><paragraph>baz]</paragraph>'
 				);
 			} );
@@ -194,29 +199,29 @@ describe( 'ParagraphCommand', () => {
 			it( 'converts all elements even if already anchored in paragraph', () => {
 				schema.registerItem( 'heading2', '$block' );
 
-				setData( document, '<paragraph>foo[</paragraph><heading2>bar]</heading2>' );
+				setData( model, '<paragraph>foo[</paragraph><heading2>bar]</heading2>' );
 
 				command.execute();
-				expect( getData( document ) ).to.equal( '<paragraph>foo[</paragraph><paragraph>bar]</paragraph>' );
+				expect( getData( model ) ).to.equal( '<paragraph>foo[</paragraph><paragraph>bar]</paragraph>' );
 			} );
 		} );
 	} );
 
 	describe( 'isEnabled', () => {
 		it( 'should be enabled when inside another block', () => {
-			setData( document, '<heading1>f{}oo</heading1>' );
+			setData( model, '<heading1>f{}oo</heading1>' );
 
 			expect( command.isEnabled ).to.be.true;
 		} );
 
 		it( 'should be disabled if inside non-block', () => {
-			setData( document, '<notBlock>f{}oo</notBlock>' );
+			setData( model, '<notBlock>f{}oo</notBlock>' );
 
 			expect( command.isEnabled ).to.be.false;
 		} );
 
 		it( 'should be disabled if selection is placed on non-block element', () => {
-			setData( document, '[<notBlock>foo</notBlock>]' );
+			setData( model, '[<notBlock>foo</notBlock>]' );
 
 			expect( command.isEnabled ).to.be.false;
 		} );