From 4d51b2e7f2538fb28f7eac1d0b14028067aa04a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 15:16:35 +0200
Subject: [PATCH 01/32] Internal: `DataController#insertContent` strips
 disallowed attributes from Text.

---
 src/controller/insertcontent.js   | 11 +++++++++++
 tests/controller/insertcontent.js |  8 ++++++++
 2 files changed, 19 insertions(+)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index c2443a8b1..0a81d83d5 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -226,6 +226,17 @@ class Insertion {
 		if ( node.is( 'element' ) ) {
 			this.handleNodes( node.getChildren(), context );
 		}
+		// When disallowed node is a text but text is allowed in current parent it means that our node
+		// contains disallowed attributes and we have to remove them.
+		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: [ this.position.parent ] } ) ) {
+			for ( const attribute of node.getAttributeKeys() ) {
+				if ( !this.schema.check( { name: '$text', attributes: attribute, inside: [ this.position.parent ] } ) ) {
+					node.removeAttribute( attribute );
+				}
+			}
+
+			this._handleNode( node, context );
+		}
 		// Try autoparagraphing.
 		else {
 			this._tryAutoparagraphing( node, context );
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 7c44e8b9a..7224f0cf4 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -591,6 +591,8 @@ describe( 'DataController', () => {
 				schema.allow( { name: 'disallowedWidget', inside: '$clipboardHolder' } );
 				schema.allow( { name: '$text', inside: 'disallowedWidget' } );
 				schema.objects.add( 'disallowedWidget' );
+
+				schema.allow( { name: '$text', attributes: 'b', inside: 'paragraph' } );
 			} );
 
 			it( 'filters out disallowed elements and leaves out the text', () => {
@@ -610,6 +612,12 @@ describe( 'DataController', () => {
 				insertHelper( '<disallowedWidget>xxx</disallowedWidget>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>f[]oo</paragraph>' );
 			} );
+
+			it( 'filters out disallowed attributes', () => {
+				setData( doc, '<paragraph>f[]oo</paragraph>' );
+				insertHelper( '<table><td>x<$text a="1" b="1">x</$text>x</td><td>y<$text a="1">y</$text>y</td></table>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
+			} );
 		} );
 	} );
 

From c4f59c2bf04014bb682ab7121682613e823f2dd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 16:03:41 +0200
Subject: [PATCH 02/32] Internal: Autoparagraphing checks and strips disallowed
 by a schema attributes.

---
 src/controller/insertcontent.js   | 37 ++++++++++++++++++++++---------
 tests/controller/insertcontent.js |  6 +++++
 2 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 0a81d83d5..3cf1b2c2d 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -229,12 +229,7 @@ class Insertion {
 		// When disallowed node is a text but text is allowed in current parent it means that our node
 		// contains disallowed attributes and we have to remove them.
 		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: [ this.position.parent ] } ) ) {
-			for ( const attribute of node.getAttributeKeys() ) {
-				if ( !this.schema.check( { name: '$text', attributes: attribute, inside: [ this.position.parent ] } ) ) {
-					node.removeAttribute( attribute );
-				}
-			}
-
+			this._stripsDisallowedAttributes( node );
 			this._handleNode( node, context );
 		}
 		// Try autoparagraphing.
@@ -336,10 +331,17 @@ class Insertion {
 		// Do not autoparagraph if the paragraph won't be allowed there,
 		// cause that would lead to an infinite loop. The paragraph would be rejected in
 		// the next _handleNode() call and we'd be here again.
-		if ( this._getAllowedIn( paragraph, this.position.parent ) && this._checkIsAllowed( node, [ paragraph ] ) ) {
-			paragraph.appendChildren( node );
+		if ( this._getAllowedIn( paragraph, this.position.parent ) ) {
+			// When node is a text and is disallowed by schema it means that contains disallowed attributes
+			// and we need to remove them.
+			if ( node.is( 'text' ) && !this._checkIsAllowed( node, [ paragraph ] ) ) {
+				this._stripsDisallowedAttributes( node, [ paragraph ] );
+			}
 
-			this._handleNode( paragraph, context );
+			if ( this._checkIsAllowed( node, [ paragraph ] ) ) {
+				paragraph.appendChildren( node );
+				this._handleNode( paragraph, context );
+			}
 		}
 	}
 
@@ -420,7 +422,7 @@ class Insertion {
 	}
 
 	/**
-	 * Checks wether according to the schema this is an object type element.
+	 * Checks whether according to the schema this is an object type element.
 	 *
 	 * @param {module:engine/model/node~Node} node The node to check.
 	 */
@@ -428,6 +430,21 @@ class Insertion {
 		return this.schema.objects.has( this._getNodeSchemaName( node ) );
 	}
 
+	/**
+	 * Removes disallowed by schema attributes from given node.
+	 *
+	 * @private
+	 * @param {module:engine/model/node~Node} node
+	 * @param {module:engine/model/schema~SchemaPath} path
+	 */
+	_stripsDisallowedAttributes( node, path = [ this.position.parent ] ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !this.schema.check( { name: '$text', attributes: attribute, inside: [ path ] } ) ) {
+				node.removeAttribute( attribute );
+			}
+		}
+	}
+
 	/**
 	 * Gets a name under which we should check this node in the schema.
 	 *
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 7224f0cf4..75bb1716c 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -618,6 +618,12 @@ describe( 'DataController', () => {
 				insertHelper( '<table><td>x<$text a="1" b="1">x</$text>x</td><td>y<$text a="1">y</$text>y</td></table>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
 			} );
+
+			it( 'filters out disallowed attributes when autoparagraphing', () => {
+				setData( doc, '<paragraph>f[]oo</paragraph>' );
+				insertHelper( '<paragraph>xxx</paragraph><$text a="1" b="1">yyy</$text>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>fxxx</paragraph><paragraph><$text b="1">yyy[]</$text>oo</paragraph>' );
+			} );
 		} );
 	} );
 

From 83c0b609b1d39a5bcce1f2ce8c9794bd7cb52120 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 16:13:30 +0200
Subject: [PATCH 03/32] Typo.

---
 src/controller/insertcontent.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 3cf1b2c2d..9304b8f7b 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -229,7 +229,7 @@ class Insertion {
 		// When disallowed node is a text but text is allowed in current parent it means that our node
 		// contains disallowed attributes and we have to remove them.
 		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: [ this.position.parent ] } ) ) {
-			this._stripsDisallowedAttributes( node );
+			this._stripDisallowedAttributes( node );
 			this._handleNode( node, context );
 		}
 		// Try autoparagraphing.
@@ -335,7 +335,7 @@ class Insertion {
 			// When node is a text and is disallowed by schema it means that contains disallowed attributes
 			// and we need to remove them.
 			if ( node.is( 'text' ) && !this._checkIsAllowed( node, [ paragraph ] ) ) {
-				this._stripsDisallowedAttributes( node, [ paragraph ] );
+				this._stripDisallowedAttributes( node, [ paragraph ] );
 			}
 
 			if ( this._checkIsAllowed( node, [ paragraph ] ) ) {
@@ -437,7 +437,7 @@ class Insertion {
 	 * @param {module:engine/model/node~Node} node
 	 * @param {module:engine/model/schema~SchemaPath} path
 	 */
-	_stripsDisallowedAttributes( node, path = [ this.position.parent ] ) {
+	_stripDisallowedAttributes( node, path = [ this.position.parent ] ) {
 		for ( const attribute of node.getAttributeKeys() ) {
 			if ( !this.schema.check( { name: '$text', attributes: attribute, inside: [ path ] } ) ) {
 				node.removeAttribute( attribute );

From 73c30368dc1f53e9a42b7cb029d6c6bb6bf82b38 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 16:25:25 +0200
Subject: [PATCH 04/32] Removed not necessary array typecasting.

---
 src/controller/insertcontent.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 9304b8f7b..2bcfb6fab 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -439,7 +439,7 @@ class Insertion {
 	 */
 	_stripDisallowedAttributes( node, path = [ this.position.parent ] ) {
 		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !this.schema.check( { name: '$text', attributes: attribute, inside: [ path ] } ) ) {
+			if ( !this.schema.check( { name: '$text', attributes: attribute, inside: path } ) ) {
 				node.removeAttribute( attribute );
 			}
 		}

From cc55cbb1b0ba41bfc6e7a31850b03751b1dfb2d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 16:26:13 +0200
Subject: [PATCH 05/32] Docs.

---
 src/controller/insertcontent.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 2bcfb6fab..7e4e996f6 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -431,7 +431,7 @@ class Insertion {
 	}
 
 	/**
-	 * Removes disallowed by schema attributes from given node.
+	 * Removes disallowed by schema attributes.
 	 *
 	 * @private
 	 * @param {module:engine/model/node~Node} node

From 7de4bb12fd6140ecbaadedc78e4f40b9a41ace61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 17:09:07 +0200
Subject: [PATCH 06/32] Used simplest format for SchemaPath.

---
 src/controller/insertcontent.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 7e4e996f6..aa2dd1aa6 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -228,7 +228,7 @@ class Insertion {
 		}
 		// When disallowed node is a text but text is allowed in current parent it means that our node
 		// contains disallowed attributes and we have to remove them.
-		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: [ this.position.parent ] } ) ) {
+		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: this.position } ) ) {
 			this._stripDisallowedAttributes( node );
 			this._handleNode( node, context );
 		}
@@ -243,7 +243,7 @@ class Insertion {
 	 */
 	_insert( node ) {
 		/* istanbul ignore if */
-		if ( !this._checkIsAllowed( node, [ this.position.parent ] ) ) {
+		if ( !this._checkIsAllowed( node, this.position ) ) {
 			// Algorithm's correctness check. We should never end up here but it's good to know that we did.
 			// Note that it would often be a silent issue if we insert node in a place where it's not allowed.
 			log.error(
@@ -262,7 +262,7 @@ class Insertion {
 		livePos.detach();
 
 		// The last inserted object should be selected because we can't put a collapsed selection after it.
-		if ( this._checkIsObject( node ) && !this.schema.check( { name: '$text', inside: [ this.position.parent ] } ) ) {
+		if ( this._checkIsObject( node ) && !this.schema.check( { name: '$text', inside: this.position } ) ) {
 			this.nodeToSelect = node;
 		} else {
 			this.nodeToSelect = null;
@@ -437,7 +437,7 @@ class Insertion {
 	 * @param {module:engine/model/node~Node} node
 	 * @param {module:engine/model/schema~SchemaPath} path
 	 */
-	_stripDisallowedAttributes( node, path = [ this.position.parent ] ) {
+	_stripDisallowedAttributes( node, path = this.position ) {
 		for ( const attribute of node.getAttributeKeys() ) {
 			if ( !this.schema.check( { name: '$text', attributes: attribute, inside: path } ) ) {
 				node.removeAttribute( attribute );

From a0be86af82b41e88a617560039a97d5d3ab67ec5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Thu, 24 Aug 2017 23:43:32 +0200
Subject: [PATCH 07/32] Added one more test for filtering attributes in
 inserted content.

---
 tests/controller/insertcontent.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 75bb1716c..b901c4174 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -613,7 +613,13 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<paragraph>f[]oo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes', () => {
+			it( 'filters out disallowed attributes when inserting text', () => {
+				setData( doc, '<paragraph>f[]oo</paragraph>' );
+				insertHelper( 'x<$text a="1" b="1">x</$text>xy<$text a="1">y</$text>y' );
+				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
+			} );
+
+			it( 'filters out disallowed attributes when inserting text in disallowed elements', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<table><td>x<$text a="1" b="1">x</$text>x</td><td>y<$text a="1">y</$text>y</td></table>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );

From 4eecd219f528c65f45c3463d83afc16f780281fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 12:00:22 +0200
Subject: [PATCH 08/32] Improved filtering to handle disallowed attributes when
 merge.

---
 src/controller/insertcontent.js   | 35 +++++++++++++++++++++++++------
 tests/controller/insertcontent.js | 24 +++++++++++++++++++++
 2 files changed, 53 insertions(+), 6 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index aa2dd1aa6..9eacf13bb 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -10,6 +10,7 @@
 import Position from '../model/position';
 import LivePosition from '../model/liveposition';
 import Element from '../model/element';
+import Text from '../model/text';
 import Range from '../model/range';
 import log from '@ckeditor/ckeditor5-utils/src/log';
 
@@ -286,6 +287,14 @@ class Insertion {
 		if ( mergeLeft ) {
 			const position = LivePosition.createFromPosition( this.position );
 
+			const children = Array.from( node.getChildren() );
+
+			// When Text is a direct child of node which is going to be merged
+			// we need to strip it from the disallowed attributes according to the new parent.
+			if ( children.some( child => child instanceof Text ) ) {
+				this._stripDisallowedAttributes( children, mergePosLeft.nodeBefore );
+			}
+
 			this.batch.merge( mergePosLeft );
 
 			this.position = Position.createFromPosition( position );
@@ -309,6 +318,14 @@ class Insertion {
 			// NOK: <p>xx[]</p> + <p>yy</p> => <p>xxyy[]</p> (when sticks to next)
 			const position = new LivePosition( this.position.root, this.position.path, 'sticksToPrevious' );
 
+			const children = Array.from( node.getChildren() );
+
+			// When Text is a direct child of node which is going to be merged
+			// we need to strip it from the disallowed attributes according to the new parent.
+			if ( children.some( child => child instanceof Text ) ) {
+				this._stripDisallowedAttributes( children, mergePosLeft.nodeAfter );
+			}
+
 			this.batch.merge( mergePosRight );
 
 			this.position = Position.createFromPosition( position );
@@ -431,16 +448,22 @@ class Insertion {
 	}
 
 	/**
-	 * Removes disallowed by schema attributes.
+	 * Removes disallowed by schema attributes from given nodes.
 	 *
 	 * @private
-	 * @param {module:engine/model/node~Node} node
+	 * @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
 	 * @param {module:engine/model/schema~SchemaPath} path
 	 */
-	_stripDisallowedAttributes( node, path = this.position ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !this.schema.check( { name: '$text', attributes: attribute, inside: path } ) ) {
-				node.removeAttribute( attribute );
+	_stripDisallowedAttributes( nodes, path = this.position ) {
+		if ( !Array.isArray( nodes ) ) {
+			nodes = [ nodes ];
+		}
+
+		for ( const node of nodes ) {
+			for ( const attribute of node.getAttributeKeys() ) {
+				if ( !this.schema.check( { name: '$text', attributes: attribute, inside: path } ) ) {
+					node.removeAttribute( attribute );
+				}
 			}
 		}
 	}
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index b901c4174..1b09aa0b2 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -300,6 +300,12 @@ describe( 'DataController', () => {
 					expect( getData( doc ) ).to.equal( '<paragraph>xyz[]</paragraph>' );
 				} );
 
+				it( 'inserts one empty paragraph', () => {
+					setData( doc, '<paragraph>f[]oo</paragraph>' );
+					insertHelper( '<paragraph></paragraph>' );
+					expect( getData( doc ) ).to.equal( '<paragraph>f[]oo</paragraph>' );
+				} );
+
 				it( 'inserts one block into a fully selected content', () => {
 					setData( doc, '<heading1>[foo</heading1><paragraph>bar]</paragraph>' );
 					insertHelper( '<heading2>xyz</heading2>' );
@@ -625,6 +631,24 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
 			} );
 
+			it( 'filters out disallowed attributes when merging #1', () => {
+				setData( doc, '<paragraph>[]foo</paragraph>' );
+				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>x<$text b="1">x</$text>x[]foo</paragraph>' );
+			} );
+
+			it( 'filters out disallowed attributes when merging #2', () => {
+				setData( doc, '<paragraph>f[]oo</paragraph>' );
+				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>x[]oo</paragraph>' );
+			} );
+
+			it( 'filters out disallowed attributes when merging #3', () => {
+				setData( doc, '<paragraph>foo[]</paragraph>' );
+				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>foox<$text b="1">x</$text>x[]</paragraph>' );
+			} );
+
 			it( 'filters out disallowed attributes when autoparagraphing', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<paragraph>xxx</paragraph><$text a="1" b="1">yyy</$text>' );

From 4cedf84117c47beee5e384785ff9de2de4fb16df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 13:06:10 +0200
Subject: [PATCH 09/32] Refactored usage of utils method.

---
 src/controller/insertcontent.js | 66 ++++++++++++++++-----------------
 1 file changed, 32 insertions(+), 34 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 9eacf13bb..5873a624f 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -230,7 +230,7 @@ class Insertion {
 		// When disallowed node is a text but text is allowed in current parent it means that our node
 		// contains disallowed attributes and we have to remove them.
 		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: this.position } ) ) {
-			this._stripDisallowedAttributes( node );
+			removeDisallowedAttributes( node, this.position, this.schema );
 			this._handleNode( node, context );
 		}
 		// Try autoparagraphing.
@@ -292,7 +292,7 @@ class Insertion {
 			// When Text is a direct child of node which is going to be merged
 			// we need to strip it from the disallowed attributes according to the new parent.
 			if ( children.some( child => child instanceof Text ) ) {
-				this._stripDisallowedAttributes( children, mergePosLeft.nodeBefore );
+				removeDisallowedAttributes( children, mergePosLeft.nodeBefore, this.schema );
 			}
 
 			this.batch.merge( mergePosLeft );
@@ -323,7 +323,7 @@ class Insertion {
 			// When Text is a direct child of node which is going to be merged
 			// we need to strip it from the disallowed attributes according to the new parent.
 			if ( children.some( child => child instanceof Text ) ) {
-				this._stripDisallowedAttributes( children, mergePosLeft.nodeAfter );
+				removeDisallowedAttributes( children, mergePosLeft.nodeAfter, this.schema );
 			}
 
 			this.batch.merge( mergePosRight );
@@ -352,7 +352,7 @@ class Insertion {
 			// When node is a text and is disallowed by schema it means that contains disallowed attributes
 			// and we need to remove them.
 			if ( node.is( 'text' ) && !this._checkIsAllowed( node, [ paragraph ] ) ) {
-				this._stripDisallowedAttributes( node, [ paragraph ] );
+				removeDisallowedAttributes( node, [ paragraph ], this.schema );
 			}
 
 			if ( this._checkIsAllowed( node, [ paragraph ] ) ) {
@@ -432,7 +432,7 @@ class Insertion {
 	 */
 	_checkIsAllowed( node, path ) {
 		return this.schema.check( {
-			name: this._getNodeSchemaName( node ),
+			name: getNodeSchemaName( node ),
 			attributes: Array.from( node.getAttributeKeys() ),
 			inside: path
 		} );
@@ -444,40 +444,38 @@ class Insertion {
 	 * @param {module:engine/model/node~Node} node The node to check.
 	 */
 	_checkIsObject( node ) {
-		return this.schema.objects.has( this._getNodeSchemaName( node ) );
+		return this.schema.objects.has( getNodeSchemaName( node ) );
 	}
+}
 
-	/**
-	 * Removes disallowed by schema attributes from given nodes.
-	 *
-	 * @private
-	 * @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
-	 * @param {module:engine/model/schema~SchemaPath} path
-	 */
-	_stripDisallowedAttributes( nodes, path = this.position ) {
-		if ( !Array.isArray( nodes ) ) {
-			nodes = [ nodes ];
-		}
+// Gets a name under which we should check this node in the schema.
+//
+// @private
+// @param {module:engine/model/node~Node} node The node.
+function getNodeSchemaName( node ) {
+	if ( node.is( 'text' ) ) {
+		return '$text';
+	}
 
-		for ( const node of nodes ) {
-			for ( const attribute of node.getAttributeKeys() ) {
-				if ( !this.schema.check( { name: '$text', attributes: attribute, inside: path } ) ) {
-					node.removeAttribute( attribute );
-				}
-			}
-		}
+	return node.name;
+}
+
+// Removes disallowed by schema attributes from given text nodes.
+//
+// @private
+// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
+// @param {module:engine/model/schema~SchemaPath} schemaPath
+// @param {module:engine/model/schema~Schema} schema
+function removeDisallowedAttributes( nodes, schemaPath, schema ) {
+	if ( !Array.isArray( nodes ) ) {
+		nodes = [ nodes ];
 	}
 
-	/**
-	 * Gets a name under which we should check this node in the schema.
-	 *
-	 * @param {module:engine/model/node~Node} node The node.
-	 */
-	_getNodeSchemaName( node ) {
-		if ( node.is( 'text' ) ) {
-			return '$text';
+	for ( const node of nodes ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
+				node.removeAttribute( attribute );
+			}
 		}
-
-		return node.name;
 	}
 }

From 1b697574e95d03e223ba075c646fa619d97146d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 13:10:08 +0200
Subject: [PATCH 10/32] Improved code style.

---
 src/controller/deletecontent.js | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index b260e7392..075aff0b7 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -208,9 +208,5 @@ function shouldEntireContentBeReplacedWithParagraph( schema, selection ) {
 		return false;
 	}
 
-	if ( !schema.check( { name: 'paragraph', inside: limitElement.name } ) ) {
-		return false;
-	}
-
-	return true;
+	return schema.check( { name: 'paragraph', inside: limitElement.name } );
 }

From 6dcd92daf8787c70ce9c00bd0fa184ef698dd639 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 13:36:30 +0200
Subject: [PATCH 11/32] Fixed incorrect schema path.

---
 src/controller/insertcontent.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 5873a624f..8f1b501f8 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -292,7 +292,7 @@ class Insertion {
 			// When Text is a direct child of node which is going to be merged
 			// we need to strip it from the disallowed attributes according to the new parent.
 			if ( children.some( child => child instanceof Text ) ) {
-				removeDisallowedAttributes( children, mergePosLeft.nodeBefore, this.schema );
+				removeDisallowedAttributes( children, [ mergePosLeft.nodeBefore ], this.schema );
 			}
 
 			this.batch.merge( mergePosLeft );
@@ -323,7 +323,7 @@ class Insertion {
 			// When Text is a direct child of node which is going to be merged
 			// we need to strip it from the disallowed attributes according to the new parent.
 			if ( children.some( child => child instanceof Text ) ) {
-				removeDisallowedAttributes( children, mergePosLeft.nodeAfter, this.schema );
+				removeDisallowedAttributes( children, [ mergePosLeft.nodeAfter ], this.schema );
 			}
 
 			this.batch.merge( mergePosRight );

From bd4b085eb53082df91bb45d3da9f7052d97f82c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 13:36:58 +0200
Subject: [PATCH 12/32] Removed duplicated test.

---
 tests/controller/deletecontent.js | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tests/controller/deletecontent.js b/tests/controller/deletecontent.js
index bb21eab97..a6f9ead9f 100644
--- a/tests/controller/deletecontent.js
+++ b/tests/controller/deletecontent.js
@@ -188,12 +188,6 @@ describe( 'DataController', () => {
 				{ leaveUnmerged: true }
 			);
 
-			test(
-				'merges second element into the first one (same name)',
-				'<paragraph>x</paragraph><paragraph>fo[o</paragraph><paragraph>b]ar</paragraph><paragraph>y</paragraph>',
-				'<paragraph>x</paragraph><paragraph>fo[]ar</paragraph><paragraph>y</paragraph>'
-			);
-
 			test(
 				'merges second element into the first one (different name)',
 				'<paragraph>x</paragraph><heading1>fo[o</heading1><paragraph>b]ar</paragraph><paragraph>y</paragraph>',

From 392ed5bbfabb9d264b7dc78e9fed2505ddbc4784 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 13:51:49 +0200
Subject: [PATCH 13/32] Simplified the code.

---
 src/controller/insertcontent.js | 21 ++++++---------------
 1 file changed, 6 insertions(+), 15 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 8f1b501f8..96d472f2f 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -10,7 +10,6 @@
 import Position from '../model/position';
 import LivePosition from '../model/liveposition';
 import Element from '../model/element';
-import Text from '../model/text';
 import Range from '../model/range';
 import log from '@ckeditor/ckeditor5-utils/src/log';
 
@@ -287,13 +286,9 @@ class Insertion {
 		if ( mergeLeft ) {
 			const position = LivePosition.createFromPosition( this.position );
 
-			const children = Array.from( node.getChildren() );
-
-			// When Text is a direct child of node which is going to be merged
-			// we need to strip it from the disallowed attributes according to the new parent.
-			if ( children.some( child => child instanceof Text ) ) {
-				removeDisallowedAttributes( children, [ mergePosLeft.nodeBefore ], this.schema );
-			}
+			// When need to check a direct child of node that is going to be merged
+			// and strip it from the disallowed attributes according to the new parent.
+			removeDisallowedAttributes( Array.from( node.getChildren() ), [ mergePosLeft.nodeBefore ], this.schema );
 
 			this.batch.merge( mergePosLeft );
 
@@ -318,13 +313,9 @@ class Insertion {
 			// NOK: <p>xx[]</p> + <p>yy</p> => <p>xxyy[]</p> (when sticks to next)
 			const position = new LivePosition( this.position.root, this.position.path, 'sticksToPrevious' );
 
-			const children = Array.from( node.getChildren() );
-
-			// When Text is a direct child of node which is going to be merged
-			// we need to strip it from the disallowed attributes according to the new parent.
-			if ( children.some( child => child instanceof Text ) ) {
-				removeDisallowedAttributes( children, [ mergePosLeft.nodeAfter ], this.schema );
-			}
+			// When need to check a direct child of node that is going to be merged
+			// and strip it from the disallowed attributes according to the new parent.
+			removeDisallowedAttributes( Array.from( node.getChildren() ), [ mergePosLeft.nodeAfter ], this.schema );
 
 			this.batch.merge( mergePosRight );
 

From 306853739bef293dd494c4d801258474b84d02ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 14:47:52 +0200
Subject: [PATCH 14/32] Added attributes filtering when merging after delete.

---
 src/controller/deletecontent.js   | 39 +++++++++++++++++++++++++++++++
 tests/controller/deletecontent.js | 24 +++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index 075aff0b7..cfec685ff 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -132,6 +132,13 @@ function mergeBranches( batch, startPos, endPos ) {
 		// To then become:
 		// <a><b>xy</b>[]</a><c>{}</c>
 		batch.merge( startPos );
+
+		// We need to check and strip disallowed attributes in direct children because after merge
+		// some attributes could end up in a parent where are disallowed.
+		//
+		// e.g. bold is disallowed for <H1>
+		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
+		removeDisallowedAttributes( Array.from( startParent.getChildren() ), [ startParent ], batch.document.schema );
 	}
 
 	// Removes empty end ancestors:
@@ -210,3 +217,35 @@ function shouldEntireContentBeReplacedWithParagraph( schema, selection ) {
 
 	return schema.check( { name: 'paragraph', inside: limitElement.name } );
 }
+
+// Gets a name under which we should check this node in the schema.
+//
+// @private
+// @param {module:engine/model/node~Node} node The node.
+function getNodeSchemaName( node ) {
+	if ( node.is( 'text' ) ) {
+		return '$text';
+	}
+
+	return node.name;
+}
+
+// Removes disallowed by schema attributes from given text nodes.
+//
+// @private
+// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
+// @param {module:engine/model/schema~SchemaPath} schemaPath
+// @param {module:engine/model/schema~Schema} schema
+function removeDisallowedAttributes( nodes, schemaPath, schema ) {
+	if ( !Array.isArray( nodes ) ) {
+		nodes = [ nodes ];
+	}
+
+	for ( const node of nodes ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
+				node.removeAttribute( attribute );
+			}
+		}
+	}
+}
diff --git a/tests/controller/deletecontent.js b/tests/controller/deletecontent.js
index a6f9ead9f..e8fe7d690 100644
--- a/tests/controller/deletecontent.js
+++ b/tests/controller/deletecontent.js
@@ -167,6 +167,12 @@ describe( 'DataController', () => {
 				schema.allow( { name: '$text', inside: 'pparent' } );
 
 				schema.allow( { name: 'paragraph', attributes: [ 'align' ] } );
+				schema.allow( { name: '$text', attributes: 'a', inside: 'paragraph' } );
+				schema.allow( { name: '$text', attributes: 'b', inside: 'paragraph' } );
+				schema.allow( { name: '$text', attributes: 'c', inside: 'paragraph' } );
+				schema.allow( { name: '$text', attributes: 'b', inside: 'heading1' } );
+				schema.allow( { name: '$text', attributes: 'c', inside: 'pchild' } );
+				schema.allow( { name: '$text', attributes: 'd', inside: 'pchild' } );
 			} );
 
 			test(
@@ -263,6 +269,12 @@ describe( 'DataController', () => {
 				expect( spyMerge.called ).to.be.true;
 			} );
 
+			test(
+				'filters out disallowed attributes after merge',
+				'<heading1>fo[o</heading1><paragraph>b]a<$text a="true" b="true">r</$text></paragraph>',
+				'<heading1>fo[]a<$text b="true">r</$text></heading1>'
+			);
+
 			// Note: in all these cases we ignore the direction of merge.
 			// If https://github.com/ckeditor/ckeditor5-engine/issues/470 was fixed we could differently treat
 			// forward and backward delete.
@@ -400,6 +412,18 @@ describe( 'DataController', () => {
 					expect( getData( doc ) )
 						.to.equal( '<paragraph>fo[]</paragraph>' );
 				} );
+
+				test(
+					'filters out disallowed attributes after merge when left',
+					'<paragraph>x<pchild>fo[o</pchild></paragraph><paragraph>y]<$text b="true" c="true">z</$text></paragraph>',
+					'<paragraph>x<pchild>fo[]<$text c="true">z</$text></pchild></paragraph>'
+				);
+
+				test(
+					'filters out disallowed attributes after merge when right',
+					'<paragraph>fo[o</paragraph><paragraph><pchild>x<$text c="true" d="true">y]z</$text></pchild></paragraph>',
+					'<paragraph>fo[]<$text c="true">z</$text></paragraph>'
+				);
 			} );
 
 			describe( 'with object elements', () => {

From 59174ec41d91bdb1e99b378f17cc7b769eb8616b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 15:27:49 +0200
Subject: [PATCH 15/32] Moved common helper functions to the model/utils.js.

---
 src/controller/deletecontent.js | 33 +----------------
 src/controller/insertcontent.js | 33 +----------------
 src/model/utils.js              | 43 ++++++++++++++++++++++
 tests/model/utils.js            | 64 +++++++++++++++++++++++++++++++++
 4 files changed, 109 insertions(+), 64 deletions(-)
 create mode 100644 src/model/utils.js
 create mode 100644 tests/model/utils.js

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index cfec685ff..98dc0bc20 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -11,6 +11,7 @@ import LivePosition from '../model/liveposition';
 import Position from '../model/position';
 import Range from '../model/range';
 import Element from '../model/element';
+import { removeDisallowedAttributes } from '../model/utils';
 
 /**
  * Deletes content of the selection and merge siblings. The resulting selection is always collapsed.
@@ -217,35 +218,3 @@ function shouldEntireContentBeReplacedWithParagraph( schema, selection ) {
 
 	return schema.check( { name: 'paragraph', inside: limitElement.name } );
 }
-
-// Gets a name under which we should check this node in the schema.
-//
-// @private
-// @param {module:engine/model/node~Node} node The node.
-function getNodeSchemaName( node ) {
-	if ( node.is( 'text' ) ) {
-		return '$text';
-	}
-
-	return node.name;
-}
-
-// Removes disallowed by schema attributes from given text nodes.
-//
-// @private
-// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
-// @param {module:engine/model/schema~SchemaPath} schemaPath
-// @param {module:engine/model/schema~Schema} schema
-function removeDisallowedAttributes( nodes, schemaPath, schema ) {
-	if ( !Array.isArray( nodes ) ) {
-		nodes = [ nodes ];
-	}
-
-	for ( const node of nodes ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
-				node.removeAttribute( attribute );
-			}
-		}
-	}
-}
diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 96d472f2f..46e369ac3 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -12,6 +12,7 @@ import LivePosition from '../model/liveposition';
 import Element from '../model/element';
 import Range from '../model/range';
 import log from '@ckeditor/ckeditor5-utils/src/log';
+import { getNodeSchemaName, removeDisallowedAttributes } from '../model/utils';
 
 /**
  * Inserts content into the editor (specified selection) as one would expect the paste
@@ -438,35 +439,3 @@ class Insertion {
 		return this.schema.objects.has( getNodeSchemaName( node ) );
 	}
 }
-
-// Gets a name under which we should check this node in the schema.
-//
-// @private
-// @param {module:engine/model/node~Node} node The node.
-function getNodeSchemaName( node ) {
-	if ( node.is( 'text' ) ) {
-		return '$text';
-	}
-
-	return node.name;
-}
-
-// Removes disallowed by schema attributes from given text nodes.
-//
-// @private
-// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
-// @param {module:engine/model/schema~SchemaPath} schemaPath
-// @param {module:engine/model/schema~Schema} schema
-function removeDisallowedAttributes( nodes, schemaPath, schema ) {
-	if ( !Array.isArray( nodes ) ) {
-		nodes = [ nodes ];
-	}
-
-	for ( const node of nodes ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
-				node.removeAttribute( attribute );
-			}
-		}
-	}
-}
diff --git a/src/model/utils.js b/src/model/utils.js
new file mode 100644
index 000000000..d0a455d9b
--- /dev/null
+++ b/src/model/utils.js
@@ -0,0 +1,43 @@
+/**
+ * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+/**
+ * @module engine/model/utils
+ */
+
+/**
+ * Gets a name under which we should check this node in the schema.
+ *
+ * @param {module:engine/model/node~Node} node The node.
+ * @returns {String} node name.
+ */
+export function getNodeSchemaName( node ) {
+	if ( node.is( 'text' ) ) {
+		return '$text';
+	}
+
+	return node.name;
+}
+
+/**
+ * Removes disallowed by schema attributes from given nodes.
+ *
+ * @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+ * @param {module:engine/model/schema~SchemaPath} schemaPath
+ * @param {module:engine/model/schema~Schema} schema
+ */
+export function removeDisallowedAttributes( nodes, schemaPath, schema ) {
+	if ( !Array.isArray( nodes ) ) {
+		nodes = [ nodes ];
+	}
+
+	for ( const node of nodes ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
+				node.removeAttribute( attribute );
+			}
+		}
+	}
+}
diff --git a/tests/model/utils.js b/tests/model/utils.js
new file mode 100644
index 000000000..05c72c06a
--- /dev/null
+++ b/tests/model/utils.js
@@ -0,0 +1,64 @@
+/**
+ * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+import { getNodeSchemaName, removeDisallowedAttributes } from '../../src/model/utils';
+import Element from '../../src/model/element';
+import Text from '../../src/model/text';
+import Document from '../../src/model/document';
+import { setData, getData } from '../../src/dev-utils/model';
+
+describe( 'model utils', () => {
+	describe( 'getNodeSchemaName()', () => {
+		it( 'should return schema name for a given Element', () => {
+			const element = new Element( 'paragraph' );
+
+			expect( getNodeSchemaName( element ) ).to.equal( 'paragraph' );
+		} );
+
+		it( 'should return schema name for a Text', () => {
+			const element = new Text();
+
+			expect( getNodeSchemaName( element ) ).to.equal( '$text' );
+		} );
+	} );
+
+	describe( 'removeDisallowedAttributes()', () => {
+		let doc;
+
+		beforeEach( () => {
+			doc = new Document();
+			doc.createRoot();
+
+			const schema = doc.schema;
+
+			schema.registerItem( 'paragraph', '$block' );
+
+			schema.allow( { name: '$text', attributes: 'a', inside: 'paragraph' } );
+			schema.allow( { name: '$text', attributes: 'c', inside: 'paragraph' } );
+		} );
+
+		it( 'should remove disallowed by schema attributes from list of nodes', () => {
+			setData( doc, '<paragraph>f<$text a="1" b="1">o</$text>ob<$text b="1" c="1">a</$text>r</paragraph>' );
+
+			const paragraph = doc.getRoot().getChild( 0 );
+
+			removeDisallowedAttributes( Array.from( paragraph.getChildren() ), [ paragraph ], doc.schema );
+
+			expect( getData( doc, { withoutSelection: true } ) )
+				.to.equal( '<paragraph>f<$text a="1">o</$text>ob<$text c="1">a</$text>r</paragraph>' );
+		} );
+
+		it( 'should remove disallowed by schema attributes from a single node', () => {
+			setData( doc, '<paragraph><$text a="1" b="1">foo</$text></paragraph>' );
+
+			const paragraph = doc.getRoot().getChild( 0 );
+
+			removeDisallowedAttributes( paragraph.getChild( 0 ), [ paragraph ], doc.schema );
+
+			expect( getData( doc, { withoutSelection: true } ) )
+				.to.equal( '<paragraph><$text a="1">foo</$text></paragraph>' );
+		} );
+	} );
+} );

From ed37d71bbab1b2ef9f5f038775730ad4f659b15b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 16:04:28 +0200
Subject: [PATCH 16/32] Increased CC to 100%.

---
 tests/controller/insertcontent.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 1b09aa0b2..727aecc8d 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -281,6 +281,17 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<heading1>foxyz[]ar</heading1>' );
 			} );
 
+			it( 'not inserts autoparagraph when paragraph is disallowed at the current position', () => {
+				doc.schema.disallow( { name: 'paragraph', inside: '$root' } );
+				doc.schema.disallow( { name: 'heading2', inside: '$root' } );
+
+				const content = new Element( 'heading2', [], [ new Text( 'bar' ) ] );
+
+				setData( doc, '[<heading1>foo</heading1>]' );
+				insertContent( dataController, content, doc.selection );
+				expect( getData( doc ) ).to.equal( '[]' );
+			} );
+
 			describe( 'block to block handling', () => {
 				it( 'inserts one paragraph', () => {
 					setData( doc, '<paragraph>f[]oo</paragraph>' );

From e22930f48efca1d4641e8f7286cf8325b533eb72 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 16:31:02 +0200
Subject: [PATCH 17/32] Refactored model util test.

---
 tests/model/utils.js | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/tests/model/utils.js b/tests/model/utils.js
index 05c72c06a..056cfda2c 100644
--- a/tests/model/utils.js
+++ b/tests/model/utils.js
@@ -7,7 +7,7 @@ import { getNodeSchemaName, removeDisallowedAttributes } from '../../src/model/u
 import Element from '../../src/model/element';
 import Text from '../../src/model/text';
 import Document from '../../src/model/document';
-import { setData, getData } from '../../src/dev-utils/model';
+import { stringify } from '../../src/dev-utils/model';
 
 describe( 'model utils', () => {
 	describe( 'getNodeSchemaName()', () => {
@@ -34,31 +34,35 @@ describe( 'model utils', () => {
 			const schema = doc.schema;
 
 			schema.registerItem( 'paragraph', '$block' );
+			schema.registerItem( 'el', '$inline' );
 
 			schema.allow( { name: '$text', attributes: 'a', inside: 'paragraph' } );
 			schema.allow( { name: '$text', attributes: 'c', inside: 'paragraph' } );
+			schema.allow( { name: 'el', attributes: 'b' } );
 		} );
 
 		it( 'should remove disallowed by schema attributes from list of nodes', () => {
-			setData( doc, '<paragraph>f<$text a="1" b="1">o</$text>ob<$text b="1" c="1">a</$text>r</paragraph>' );
+			const paragraph = new Element( 'paragraph' );
+			const el = new Element( 'el', { a: 1, b: 1, c: 1 } );
+			const foo = new Text( 'foo', { a: 1, b: 1 } );
+			const bar = new Text( 'bar' );
+			const biz = new Text( 'biz', { b: 1, c: 1 } );
 
-			const paragraph = doc.getRoot().getChild( 0 );
+			paragraph.appendChildren( [ el, foo, bar, biz ] );
 
 			removeDisallowedAttributes( Array.from( paragraph.getChildren() ), [ paragraph ], doc.schema );
 
-			expect( getData( doc, { withoutSelection: true } ) )
-				.to.equal( '<paragraph>f<$text a="1">o</$text>ob<$text c="1">a</$text>r</paragraph>' );
+			expect( stringify( paragraph ) )
+				.to.equal( '<paragraph><el b="1"></el><$text a="1">foo</$text>bar<$text c="1">biz</$text></paragraph>' );
 		} );
 
 		it( 'should remove disallowed by schema attributes from a single node', () => {
-			setData( doc, '<paragraph><$text a="1" b="1">foo</$text></paragraph>' );
+			const paragraph = new Element( 'paragraph' );
+			const foo = new Text( 'foo', { a: 1, b: 1 } );
 
-			const paragraph = doc.getRoot().getChild( 0 );
+			removeDisallowedAttributes( foo, [ paragraph ], doc.schema );
 
-			removeDisallowedAttributes( paragraph.getChild( 0 ), [ paragraph ], doc.schema );
-
-			expect( getData( doc, { withoutSelection: true } ) )
-				.to.equal( '<paragraph><$text a="1">foo</$text></paragraph>' );
+			expect( stringify( foo ) ).to.equal( '<$text a="1">foo</$text>' );
 		} );
 	} );
 } );

From b54c43bb1e5ffa1bfea8955cc5a0827e42322420 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Mon, 28 Aug 2017 20:27:47 +0200
Subject: [PATCH 18/32] Removed model utils and refactored removing disallowed
 attributes.

---
 src/controller/deletecontent.js   | 28 ++++++++++++-
 src/controller/insertcontent.js   | 42 +++++++++++++++----
 src/model/utils.js                | 43 -------------------
 tests/controller/deletecontent.js | 21 +++++-----
 tests/controller/insertcontent.js |  1 +
 tests/model/utils.js              | 68 -------------------------------
 6 files changed, 71 insertions(+), 132 deletions(-)
 delete mode 100644 src/model/utils.js
 delete mode 100644 tests/model/utils.js

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index 98dc0bc20..29f669608 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -11,7 +11,6 @@ import LivePosition from '../model/liveposition';
 import Position from '../model/position';
 import Range from '../model/range';
 import Element from '../model/element';
-import { removeDisallowedAttributes } from '../model/utils';
 
 /**
  * Deletes content of the selection and merge siblings. The resulting selection is always collapsed.
@@ -139,7 +138,7 @@ function mergeBranches( batch, startPos, endPos ) {
 		//
 		// e.g. bold is disallowed for <H1>
 		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
-		removeDisallowedAttributes( Array.from( startParent.getChildren() ), [ startParent ], batch.document.schema );
+		removeDisallowedAttributes( batch, Array.from( startParent.getChildren() ), [ startParent ] );
 	}
 
 	// Removes empty end ancestors:
@@ -218,3 +217,28 @@ function shouldEntireContentBeReplacedWithParagraph( schema, selection ) {
 
 	return schema.check( { name: 'paragraph', inside: limitElement.name } );
 }
+
+// Gets a name under which we should check this node in the schema.
+//
+// @param {module:engine/model/node~Node} node The node.
+// @returns {String} node name.
+function getNodeSchemaName( node ) {
+	return node.is( 'text' ) ? '$text' : node.name;
+}
+
+// Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes.
+//
+// @param {module:engine/model/batch~Batch} batch Batch to which the deltas will be added.
+// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+// @param {module:engine/model/schema~SchemaPath} schemaPath
+function removeDisallowedAttributes( batch, nodes, schemaPath ) {
+	const schema = batch.document.schema;
+
+	for ( const node of nodes ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
+				batch.removeAttribute( node, attribute );
+			}
+		}
+	}
+}
diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 46e369ac3..d70f570f4 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -12,7 +12,6 @@ import LivePosition from '../model/liveposition';
 import Element from '../model/element';
 import Range from '../model/range';
 import log from '@ckeditor/ckeditor5-utils/src/log';
-import { getNodeSchemaName, removeDisallowedAttributes } from '../model/utils';
 
 /**
  * Inserts content into the editor (specified selection) as one would expect the paste
@@ -227,10 +226,10 @@ class Insertion {
 		if ( node.is( 'element' ) ) {
 			this.handleNodes( node.getChildren(), context );
 		}
-		// When disallowed node is a text but text is allowed in current parent it means that our node
+		// When disallowed node is a text but text is allowed in current position it means that our node
 		// contains disallowed attributes and we have to remove them.
 		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: this.position } ) ) {
-			removeDisallowedAttributes( node, this.position, this.schema );
+			removeDisallowedAttributes( this.schema, node, this.position );
 			this._handleNode( node, context );
 		}
 		// Try autoparagraphing.
@@ -287,9 +286,9 @@ class Insertion {
 		if ( mergeLeft ) {
 			const position = LivePosition.createFromPosition( this.position );
 
-			// When need to check a direct child of node that is going to be merged
+			// When need to check a children of node that is going to be merged
 			// and strip it from the disallowed attributes according to the new parent.
-			removeDisallowedAttributes( Array.from( node.getChildren() ), [ mergePosLeft.nodeBefore ], this.schema );
+			removeDisallowedAttributes( this.schema, Array.from( node.getChildren() ), [ mergePosLeft.nodeBefore ] );
 
 			this.batch.merge( mergePosLeft );
 
@@ -314,9 +313,9 @@ class Insertion {
 			// NOK: <p>xx[]</p> + <p>yy</p> => <p>xxyy[]</p> (when sticks to next)
 			const position = new LivePosition( this.position.root, this.position.path, 'sticksToPrevious' );
 
-			// When need to check a direct child of node that is going to be merged
+			// When need to check a children of node that is going to be merged
 			// and strip it from the disallowed attributes according to the new parent.
-			removeDisallowedAttributes( Array.from( node.getChildren() ), [ mergePosLeft.nodeAfter ], this.schema );
+			removeDisallowedAttributes( this.schema, Array.from( node.getChildren() ), [ mergePosRight.nodeAfter ] );
 
 			this.batch.merge( mergePosRight );
 
@@ -344,7 +343,7 @@ class Insertion {
 			// When node is a text and is disallowed by schema it means that contains disallowed attributes
 			// and we need to remove them.
 			if ( node.is( 'text' ) && !this._checkIsAllowed( node, [ paragraph ] ) ) {
-				removeDisallowedAttributes( node, [ paragraph ], this.schema );
+				removeDisallowedAttributes( this.schema, node, [ paragraph ] );
 			}
 
 			if ( this._checkIsAllowed( node, [ paragraph ] ) ) {
@@ -439,3 +438,30 @@ class Insertion {
 		return this.schema.objects.has( getNodeSchemaName( node ) );
 	}
 }
+
+// Gets a name under which we should check this node in the schema.
+//
+// @param {module:engine/model/node~Node} node The node.
+// @returns {String} node name.
+function getNodeSchemaName( node ) {
+	return node.is( 'text' ) ? '$text' : node.name;
+}
+
+// Removes disallowed by schema attributes from given nodes.
+//
+// @param {module:engine/model/schema~Schema} schema
+// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+// @param {module:engine/model/schema~SchemaPath} schemaPath
+export function removeDisallowedAttributes( schema, nodes, schemaPath ) {
+	if ( !Array.isArray( nodes ) ) {
+		nodes = [ nodes ];
+	}
+
+	for ( const node of nodes ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
+				node.removeAttribute( attribute );
+			}
+		}
+	}
+}
diff --git a/src/model/utils.js b/src/model/utils.js
deleted file mode 100644
index d0a455d9b..000000000
--- a/src/model/utils.js
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
- * For licensing, see LICENSE.md.
- */
-
-/**
- * @module engine/model/utils
- */
-
-/**
- * Gets a name under which we should check this node in the schema.
- *
- * @param {module:engine/model/node~Node} node The node.
- * @returns {String} node name.
- */
-export function getNodeSchemaName( node ) {
-	if ( node.is( 'text' ) ) {
-		return '$text';
-	}
-
-	return node.name;
-}
-
-/**
- * Removes disallowed by schema attributes from given nodes.
- *
- * @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
- * @param {module:engine/model/schema~SchemaPath} schemaPath
- * @param {module:engine/model/schema~Schema} schema
- */
-export function removeDisallowedAttributes( nodes, schemaPath, schema ) {
-	if ( !Array.isArray( nodes ) ) {
-		nodes = [ nodes ];
-	}
-
-	for ( const node of nodes ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
-				node.removeAttribute( attribute );
-			}
-		}
-	}
-}
diff --git a/tests/controller/deletecontent.js b/tests/controller/deletecontent.js
index e8fe7d690..8074b27ca 100644
--- a/tests/controller/deletecontent.js
+++ b/tests/controller/deletecontent.js
@@ -155,9 +155,9 @@ describe( 'DataController', () => {
 
 				schema.registerItem( 'paragraph', '$block' );
 				schema.registerItem( 'heading1', '$block' );
+				schema.registerItem( 'image', '$inline' );
 				schema.registerItem( 'pchild' );
 				schema.registerItem( 'pparent' );
-				schema.registerItem( 'image', '$inline' );
 
 				schema.allow( { name: 'pchild', inside: 'paragraph' } );
 				schema.allow( { name: '$text', inside: 'pchild' } );
@@ -167,12 +167,11 @@ describe( 'DataController', () => {
 				schema.allow( { name: '$text', inside: 'pparent' } );
 
 				schema.allow( { name: 'paragraph', attributes: [ 'align' ] } );
-				schema.allow( { name: '$text', attributes: 'a', inside: 'paragraph' } );
-				schema.allow( { name: '$text', attributes: 'b', inside: 'paragraph' } );
-				schema.allow( { name: '$text', attributes: 'c', inside: 'paragraph' } );
-				schema.allow( { name: '$text', attributes: 'b', inside: 'heading1' } );
-				schema.allow( { name: '$text', attributes: 'c', inside: 'pchild' } );
-				schema.allow( { name: '$text', attributes: 'd', inside: 'pchild' } );
+				schema.allow( { name: 'image', attributes: [ 'a', 'b' ], inside: 'paragraph' } );
+				schema.allow( { name: 'image', attributes: [ 'b' ], inside: 'heading1' } );
+				schema.allow( { name: '$text', attributes: [ 'a', 'b', 'c' ], inside: 'paragraph' } );
+				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'heading1' } );
+				schema.allow( { name: '$text', attributes: [ 'c', 'd' ], inside: 'pchild' } );
 			} );
 
 			test(
@@ -271,8 +270,8 @@ describe( 'DataController', () => {
 
 			test(
 				'filters out disallowed attributes after merge',
-				'<heading1>fo[o</heading1><paragraph>b]a<$text a="true" b="true">r</$text></paragraph>',
-				'<heading1>fo[]a<$text b="true">r</$text></heading1>'
+				'<heading1>fo[o</heading1><paragraph>b]a<$text a="1" b="1">r</$text><image a="1" b="1"></image></paragraph>',
+				'<heading1>fo[]a<$text b="1">r</$text><image b="1"></image></heading1>'
 			);
 
 			// Note: in all these cases we ignore the direction of merge.
@@ -414,13 +413,13 @@ describe( 'DataController', () => {
 				} );
 
 				test(
-					'filters out disallowed attributes after merge when left',
+					'filters out disallowed attributes after left merge',
 					'<paragraph>x<pchild>fo[o</pchild></paragraph><paragraph>y]<$text b="true" c="true">z</$text></paragraph>',
 					'<paragraph>x<pchild>fo[]<$text c="true">z</$text></pchild></paragraph>'
 				);
 
 				test(
-					'filters out disallowed attributes after merge when right',
+					'filters out disallowed attributes after right merge',
 					'<paragraph>fo[o</paragraph><paragraph><pchild>x<$text c="true" d="true">y]z</$text></pchild></paragraph>',
 					'<paragraph>fo[]<$text c="true">z</$text></paragraph>'
 				);
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 727aecc8d..b3499740c 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -593,6 +593,7 @@ describe( 'DataController', () => {
 				const schema = doc.schema;
 
 				schema.registerItem( 'paragraph', '$block' );
+				schema.registerItem( 'heading1', '$block' );
 
 				// Let's use table as an example of content which needs to be filtered out.
 				schema.registerItem( 'table' );
diff --git a/tests/model/utils.js b/tests/model/utils.js
deleted file mode 100644
index 056cfda2c..000000000
--- a/tests/model/utils.js
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
- * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
- * For licensing, see LICENSE.md.
- */
-
-import { getNodeSchemaName, removeDisallowedAttributes } from '../../src/model/utils';
-import Element from '../../src/model/element';
-import Text from '../../src/model/text';
-import Document from '../../src/model/document';
-import { stringify } from '../../src/dev-utils/model';
-
-describe( 'model utils', () => {
-	describe( 'getNodeSchemaName()', () => {
-		it( 'should return schema name for a given Element', () => {
-			const element = new Element( 'paragraph' );
-
-			expect( getNodeSchemaName( element ) ).to.equal( 'paragraph' );
-		} );
-
-		it( 'should return schema name for a Text', () => {
-			const element = new Text();
-
-			expect( getNodeSchemaName( element ) ).to.equal( '$text' );
-		} );
-	} );
-
-	describe( 'removeDisallowedAttributes()', () => {
-		let doc;
-
-		beforeEach( () => {
-			doc = new Document();
-			doc.createRoot();
-
-			const schema = doc.schema;
-
-			schema.registerItem( 'paragraph', '$block' );
-			schema.registerItem( 'el', '$inline' );
-
-			schema.allow( { name: '$text', attributes: 'a', inside: 'paragraph' } );
-			schema.allow( { name: '$text', attributes: 'c', inside: 'paragraph' } );
-			schema.allow( { name: 'el', attributes: 'b' } );
-		} );
-
-		it( 'should remove disallowed by schema attributes from list of nodes', () => {
-			const paragraph = new Element( 'paragraph' );
-			const el = new Element( 'el', { a: 1, b: 1, c: 1 } );
-			const foo = new Text( 'foo', { a: 1, b: 1 } );
-			const bar = new Text( 'bar' );
-			const biz = new Text( 'biz', { b: 1, c: 1 } );
-
-			paragraph.appendChildren( [ el, foo, bar, biz ] );
-
-			removeDisallowedAttributes( Array.from( paragraph.getChildren() ), [ paragraph ], doc.schema );
-
-			expect( stringify( paragraph ) )
-				.to.equal( '<paragraph><el b="1"></el><$text a="1">foo</$text>bar<$text c="1">biz</$text></paragraph>' );
-		} );
-
-		it( 'should remove disallowed by schema attributes from a single node', () => {
-			const paragraph = new Element( 'paragraph' );
-			const foo = new Text( 'foo', { a: 1, b: 1 } );
-
-			removeDisallowedAttributes( foo, [ paragraph ], doc.schema );
-
-			expect( stringify( foo ) ).to.equal( '<$text a="1">foo</$text>' );
-		} );
-	} );
-} );

From f6de62fc3ca3e43c7390b09ea72aee4f0504ebeb Mon Sep 17 00:00:00 2001
From: Szymon Cofalik <s.cofalik@cksource.com>
Date: Tue, 29 Aug 2017 15:16:24 +0200
Subject: [PATCH 19/32] Docs: minor docs corrections.

---
 src/controller/insertcontent.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index d70f570f4..1ade7012c 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -222,17 +222,17 @@ class Insertion {
 	 * @param {Object} context
 	 */
 	_handleDisallowedNode( node, context ) {
-		// Try inserting its children (strip the parent).
+		// If the node is an element, try inserting its children (strip the parent).
 		if ( node.is( 'element' ) ) {
 			this.handleNodes( node.getChildren(), context );
 		}
-		// When disallowed node is a text but text is allowed in current position it means that our node
+		// If the node is a text and bare text is allowed in current position it means that the node
 		// contains disallowed attributes and we have to remove them.
-		else if ( node.is( 'text' ) && this.schema.check( { name: '$text', inside: this.position } ) ) {
+		else if ( this.schema.check( { name: '$text', inside: this.position } ) ) {
 			removeDisallowedAttributes( this.schema, node, this.position );
 			this._handleNode( node, context );
 		}
-		// Try autoparagraphing.
+		// If text is not allowed, try autoparagraphing.
 		else {
 			this._tryAutoparagraphing( node, context );
 		}
@@ -286,7 +286,7 @@ class Insertion {
 		if ( mergeLeft ) {
 			const position = LivePosition.createFromPosition( this.position );
 
-			// When need to check a children of node that is going to be merged
+			// We need to check a children of node that is going to be merged
 			// and strip it from the disallowed attributes according to the new parent.
 			removeDisallowedAttributes( this.schema, Array.from( node.getChildren() ), [ mergePosLeft.nodeBefore ] );
 
@@ -313,7 +313,7 @@ class Insertion {
 			// NOK: <p>xx[]</p> + <p>yy</p> => <p>xxyy[]</p> (when sticks to next)
 			const position = new LivePosition( this.position.root, this.position.path, 'sticksToPrevious' );
 
-			// When need to check a children of node that is going to be merged
+			// We need to check a children of node that is going to be merged
 			// and strip it from the disallowed attributes according to the new parent.
 			removeDisallowedAttributes( this.schema, Array.from( node.getChildren() ), [ mergePosRight.nodeAfter ] );
 

From cb305e7e922a831205390bc841a4f2f888557147 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Tue, 29 Aug 2017 15:32:11 +0200
Subject: [PATCH 20/32] Remove unnecessary export.

---
 src/controller/insertcontent.js | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 1ade7012c..bb8376e54 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -229,7 +229,7 @@ class Insertion {
 		// If the node is a text and bare text is allowed in current position it means that the node
 		// contains disallowed attributes and we have to remove them.
 		else if ( this.schema.check( { name: '$text', inside: this.position } ) ) {
-			removeDisallowedAttributes( this.schema, node, this.position );
+			removeDisallowedAttributes( this.schema, [ node ], this.position );
 			this._handleNode( node, context );
 		}
 		// If text is not allowed, try autoparagraphing.
@@ -343,7 +343,7 @@ class Insertion {
 			// When node is a text and is disallowed by schema it means that contains disallowed attributes
 			// and we need to remove them.
 			if ( node.is( 'text' ) && !this._checkIsAllowed( node, [ paragraph ] ) ) {
-				removeDisallowedAttributes( this.schema, node, [ paragraph ] );
+				removeDisallowedAttributes( this.schema, [ node ], [ paragraph ] );
 			}
 
 			if ( this._checkIsAllowed( node, [ paragraph ] ) ) {
@@ -442,7 +442,7 @@ class Insertion {
 // Gets a name under which we should check this node in the schema.
 //
 // @param {module:engine/model/node~Node} node The node.
-// @returns {String} node name.
+// @returns {String} Node name.
 function getNodeSchemaName( node ) {
 	return node.is( 'text' ) ? '$text' : node.name;
 }
@@ -450,13 +450,9 @@ function getNodeSchemaName( node ) {
 // Removes disallowed by schema attributes from given nodes.
 //
 // @param {module:engine/model/schema~Schema} schema
-// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+// @param {Array<module:engine/model/node~Node>} nodes List of nodes to filter.
 // @param {module:engine/model/schema~SchemaPath} schemaPath
-export function removeDisallowedAttributes( schema, nodes, schemaPath ) {
-	if ( !Array.isArray( nodes ) ) {
-		nodes = [ nodes ];
-	}
-
+function removeDisallowedAttributes( schema, nodes, schemaPath ) {
 	for ( const node of nodes ) {
 		for ( const attribute of node.getAttributeKeys() ) {
 			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {

From 0dc237fa53a20807b0fdd39bffa9dfb86b3579a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Tue, 29 Aug 2017 16:14:16 +0200
Subject: [PATCH 21/32] Used position instead of parent as a schema path.

---
 src/controller/deletecontent.js | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index 29f669608..0c9952e2e 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -111,8 +111,8 @@ function mergeBranches( batch, startPos, endPos ) {
 	// <a><b>x[]</b></a><c><d>{}y</d></c>
 	// will become:
 	// <a><b>xy</b>[]</a><c>{}</c>
-	startPos = Position.createAfter( startParent );
-	endPos = Position.createBefore( endParent );
+	const nextStartPos = Position.createAfter( startParent );
+	let nextEndPos = Position.createBefore( endParent );
 
 	if ( endParent.isEmpty ) {
 		batch.remove( endParent );
@@ -125,20 +125,20 @@ function mergeBranches( batch, startPos, endPos ) {
 
 		// Move the end parent only if needed.
 		// E.g. not in this case: <p>ab</p>[]{}<p>cd</p>
-		if ( !endPos.isEqual( startPos ) ) {
-			batch.move( endParent, startPos );
+		if ( !nextEndPos.isEqual( nextStartPos ) ) {
+			batch.move( endParent, nextStartPos );
 		}
 
 		// To then become:
 		// <a><b>xy</b>[]</a><c>{}</c>
-		batch.merge( startPos );
+		batch.merge( nextStartPos );
 
 		// We need to check and strip disallowed attributes in direct children because after merge
 		// some attributes could end up in a parent where are disallowed.
 		//
 		// e.g. bold is disallowed for <H1>
 		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
-		removeDisallowedAttributes( batch, Array.from( startParent.getChildren() ), [ startParent ] );
+		removeDisallowedAttributes( batch, Array.from( startParent.getChildren() ), startPos );
 	}
 
 	// Removes empty end ancestors:
@@ -146,16 +146,16 @@ function mergeBranches( batch, startPos, endPos ) {
 	// becomes:
 	// <a>fo[]</a><b><a>{}</a></b>
 	// So we can remove <a> and <b>.
-	while ( endPos.parent.isEmpty ) {
-		const parentToRemove = endPos.parent;
+	while ( nextEndPos.parent.isEmpty ) {
+		const parentToRemove = nextEndPos.parent;
 
-		endPos = Position.createBefore( parentToRemove );
+		nextEndPos = Position.createBefore( parentToRemove );
 
 		batch.remove( parentToRemove );
 	}
 
 	// Continue merging next level.
-	mergeBranches( batch, startPos, endPos );
+	mergeBranches( batch, nextStartPos, nextEndPos );
 }
 
 function shouldAutoparagraph( doc, position ) {

From f8bbac9d12abcae8dc984f19e81561bc9d5b7af3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Tue, 29 Aug 2017 17:51:31 +0200
Subject: [PATCH 22/32] Added filtering of nested nodes in deleteContent.

---
 src/controller/deletecontent.js   | 38 +++++++++--------
 tests/controller/deletecontent.js | 68 ++++++++++++++++++++-----------
 2 files changed, 66 insertions(+), 40 deletions(-)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index 0c9952e2e..1c6dcf015 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -68,6 +68,13 @@ export default function deleteContent( selection, batch, options = {} ) {
 	// want to override that behavior anyway.
 	if ( !options.leaveUnmerged ) {
 		mergeBranches( batch, startPos, endPos );
+
+		// We need to check and strip disallowed attributes in all nested nodes because after merge
+		// some attributes could end up in a path where are disallowed.
+		//
+		// e.g. bold is disallowed for <H1>
+		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
+		removeDisallowedAttributes( batch, Array.from( startPos.parent.getChildren() ), startPos );
 	}
 
 	selection.setCollapsedAt( startPos );
@@ -111,8 +118,8 @@ function mergeBranches( batch, startPos, endPos ) {
 	// <a><b>x[]</b></a><c><d>{}y</d></c>
 	// will become:
 	// <a><b>xy</b>[]</a><c>{}</c>
-	const nextStartPos = Position.createAfter( startParent );
-	let nextEndPos = Position.createBefore( endParent );
+	startPos = Position.createAfter( startParent );
+	endPos = Position.createBefore( endParent );
 
 	if ( endParent.isEmpty ) {
 		batch.remove( endParent );
@@ -125,20 +132,13 @@ function mergeBranches( batch, startPos, endPos ) {
 
 		// Move the end parent only if needed.
 		// E.g. not in this case: <p>ab</p>[]{}<p>cd</p>
-		if ( !nextEndPos.isEqual( nextStartPos ) ) {
-			batch.move( endParent, nextStartPos );
+		if ( !endPos.isEqual( startPos ) ) {
+			batch.move( endParent, startPos );
 		}
 
 		// To then become:
 		// <a><b>xy</b>[]</a><c>{}</c>
-		batch.merge( nextStartPos );
-
-		// We need to check and strip disallowed attributes in direct children because after merge
-		// some attributes could end up in a parent where are disallowed.
-		//
-		// e.g. bold is disallowed for <H1>
-		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
-		removeDisallowedAttributes( batch, Array.from( startParent.getChildren() ), startPos );
+		batch.merge( startPos );
 	}
 
 	// Removes empty end ancestors:
@@ -146,16 +146,16 @@ function mergeBranches( batch, startPos, endPos ) {
 	// becomes:
 	// <a>fo[]</a><b><a>{}</a></b>
 	// So we can remove <a> and <b>.
-	while ( nextEndPos.parent.isEmpty ) {
-		const parentToRemove = nextEndPos.parent;
+	while ( endPos.parent.isEmpty ) {
+		const parentToRemove = endPos.parent;
 
-		nextEndPos = Position.createBefore( parentToRemove );
+		endPos = Position.createBefore( parentToRemove );
 
 		batch.remove( parentToRemove );
 	}
 
 	// Continue merging next level.
-	mergeBranches( batch, nextStartPos, nextEndPos );
+	mergeBranches( batch, startPos, endPos );
 }
 
 function shouldAutoparagraph( doc, position ) {
@@ -226,7 +226,7 @@ function getNodeSchemaName( node ) {
 	return node.is( 'text' ) ? '$text' : node.name;
 }
 
-// Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes.
+// Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes and its children.
 //
 // @param {module:engine/model/batch~Batch} batch Batch to which the deltas will be added.
 // @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
@@ -240,5 +240,9 @@ function removeDisallowedAttributes( batch, nodes, schemaPath ) {
 				batch.removeAttribute( node, attribute );
 			}
 		}
+
+		if ( node.is( 'element' ) ) {
+			removeDisallowedAttributes( batch, Array.from( node.getChildren() ), Position.createAt( node ) );
+		}
 	}
 }
diff --git a/tests/controller/deletecontent.js b/tests/controller/deletecontent.js
index 8074b27ca..78a537a4f 100644
--- a/tests/controller/deletecontent.js
+++ b/tests/controller/deletecontent.js
@@ -167,11 +167,6 @@ describe( 'DataController', () => {
 				schema.allow( { name: '$text', inside: 'pparent' } );
 
 				schema.allow( { name: 'paragraph', attributes: [ 'align' ] } );
-				schema.allow( { name: 'image', attributes: [ 'a', 'b' ], inside: 'paragraph' } );
-				schema.allow( { name: 'image', attributes: [ 'b' ], inside: 'heading1' } );
-				schema.allow( { name: '$text', attributes: [ 'a', 'b', 'c' ], inside: 'paragraph' } );
-				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'heading1' } );
-				schema.allow( { name: '$text', attributes: [ 'c', 'd' ], inside: 'pchild' } );
 			} );
 
 			test(
@@ -268,12 +263,6 @@ describe( 'DataController', () => {
 				expect( spyMerge.called ).to.be.true;
 			} );
 
-			test(
-				'filters out disallowed attributes after merge',
-				'<heading1>fo[o</heading1><paragraph>b]a<$text a="1" b="1">r</$text><image a="1" b="1"></image></paragraph>',
-				'<heading1>fo[]a<$text b="1">r</$text><image b="1"></image></heading1>'
-			);
-
 			// Note: in all these cases we ignore the direction of merge.
 			// If https://github.com/ckeditor/ckeditor5-engine/issues/470 was fixed we could differently treat
 			// forward and backward delete.
@@ -411,18 +400,6 @@ describe( 'DataController', () => {
 					expect( getData( doc ) )
 						.to.equal( '<paragraph>fo[]</paragraph>' );
 				} );
-
-				test(
-					'filters out disallowed attributes after left merge',
-					'<paragraph>x<pchild>fo[o</pchild></paragraph><paragraph>y]<$text b="true" c="true">z</$text></paragraph>',
-					'<paragraph>x<pchild>fo[]<$text c="true">z</$text></pchild></paragraph>'
-				);
-
-				test(
-					'filters out disallowed attributes after right merge',
-					'<paragraph>fo[o</paragraph><paragraph><pchild>x<$text c="true" d="true">y]z</$text></pchild></paragraph>',
-					'<paragraph>fo[]<$text c="true">z</$text></paragraph>'
-				);
 			} );
 
 			describe( 'with object elements', () => {
@@ -453,6 +430,51 @@ describe( 'DataController', () => {
 					'<paragraph>ba[]</paragraph><blockWidget><nestedEditable>oo</nestedEditable></blockWidget>'
 				);
 			} );
+
+			describe( 'filtering out', () => {
+				beforeEach( () => {
+					const schema = doc.schema;
+
+					schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'paragraph' } );
+					schema.allow( { name: '$text', attributes: [ 'b', 'c' ], inside: 'pchild' } );
+					schema.allow( { name: 'pchild', inside: 'pchild' } );
+					schema.disallow( { name: '$text', attributes: [ 'c' ], inside: 'pchild pchild' } );
+				} );
+
+				test(
+					'filters out disallowed attributes after left merge',
+					'<paragraph>x<pchild>fo[o</pchild></paragraph><paragraph>y]<$text a="1" b="1">z</$text></paragraph>',
+					'<paragraph>x<pchild>fo[]<$text b="1">z</$text></pchild></paragraph>'
+				);
+
+				test(
+					'filters out disallowed attributes from nested nodes after left merge',
+					'<paragraph>' +
+						'x' +
+						'<pchild>fo[o</pchild>' +
+					'</paragraph>' +
+					'<paragraph>' +
+						'b]a<$text a="1" b="1">r</$text>' +
+						'<pchild>b<$text b="1" c="1">i</$text>z</pchild>' +
+						'y' +
+					'</paragraph>',
+
+					'<paragraph>' +
+						'x' +
+						'<pchild>' +
+							'fo[]a<$text b="1">r</$text>' +
+							'<pchild>b<$text b="1">i</$text>z</pchild>' +
+							'y' +
+						'</pchild>' +
+					'</paragraph>'
+				);
+
+				test(
+					'filters out disallowed attributes after right merge',
+					'<paragraph>fo[o</paragraph><paragraph><pchild>x<$text b="1" c="1">y]z</$text></pchild></paragraph>',
+					'<paragraph>fo[]<$text b="1">z</$text></paragraph>'
+				);
+			} );
 		} );
 
 		describe( 'in element selections scenarios', () => {

From 82ee93ae6b198545303dfbd874352427ab735c19 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Wed, 30 Aug 2017 10:55:26 +0200
Subject: [PATCH 23/32] Improved filtering of nested elements after merge.

---
 src/controller/insertcontent.js   | 37 ++++++++++++++++++++++++-------
 tests/controller/insertcontent.js | 11 +++++++++
 2 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index bb8376e54..b8329ce4f 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -286,12 +286,12 @@ class Insertion {
 		if ( mergeLeft ) {
 			const position = LivePosition.createFromPosition( this.position );
 
-			// We need to check a children of node that is going to be merged
-			// and strip it from the disallowed attributes according to the new parent.
-			removeDisallowedAttributes( this.schema, Array.from( node.getChildren() ), [ mergePosLeft.nodeBefore ] );
-
 			this.batch.merge( mergePosLeft );
 
+			// We need to check and strip disallowed attributes in all nested nodes because after merge
+			// some attributes could end up in a path where are disallowed.
+			removeDisallowedAttributesOnBatch( this.batch, Array.from( this.position.parent.getChildren() ), position );
+
 			this.position = Position.createFromPosition( position );
 			position.detach();
 		}
@@ -313,12 +313,12 @@ class Insertion {
 			// NOK: <p>xx[]</p> + <p>yy</p> => <p>xxyy[]</p> (when sticks to next)
 			const position = new LivePosition( this.position.root, this.position.path, 'sticksToPrevious' );
 
-			// We need to check a children of node that is going to be merged
-			// and strip it from the disallowed attributes according to the new parent.
-			removeDisallowedAttributes( this.schema, Array.from( node.getChildren() ), [ mergePosRight.nodeAfter ] );
-
 			this.batch.merge( mergePosRight );
 
+			// We need to check and strip disallowed attributes in all nested nodes because after merge
+			// some attributes could end up in a place where are disallowed.
+			removeDisallowedAttributesOnBatch( this.batch, Array.from( this.position.parent.getChildren() ), position );
+
 			this.position = Position.createFromPosition( position );
 			position.detach();
 		}
@@ -461,3 +461,24 @@ function removeDisallowedAttributes( schema, nodes, schemaPath ) {
 		}
 	}
 }
+
+// Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes and its children.
+//
+// @param {module:engine/model/batch~Batch} batch Batch to which the deltas will be added.
+// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+// @param {module:engine/model/schema~SchemaPath} schemaPath
+function removeDisallowedAttributesOnBatch( batch, nodes, schemaPath ) {
+	const schema = batch.document.schema;
+
+	for ( const node of nodes ) {
+		for ( const attribute of node.getAttributeKeys() ) {
+			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
+				batch.removeAttribute( node, attribute );
+			}
+		}
+
+		if ( node.is( 'element' ) ) {
+			removeDisallowedAttributesOnBatch( batch, Array.from( node.getChildren() ), Position.createAt( node ) );
+		}
+	}
+}
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index b3499740c..95a1a7e95 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -594,6 +594,7 @@ describe( 'DataController', () => {
 
 				schema.registerItem( 'paragraph', '$block' );
 				schema.registerItem( 'heading1', '$block' );
+				schema.registerItem( 'child', '$block' );
 
 				// Let's use table as an example of content which needs to be filtered out.
 				schema.registerItem( 'table' );
@@ -610,7 +611,11 @@ describe( 'DataController', () => {
 				schema.allow( { name: '$text', inside: 'disallowedWidget' } );
 				schema.objects.add( 'disallowedWidget' );
 
+				schema.allow( { name: 'child', inside: 'paragraph' } );
+				schema.allow( { name: 'child', inside: 'heading1' } );
 				schema.allow( { name: '$text', attributes: 'b', inside: 'paragraph' } );
+				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'paragraph child' } );
+				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'heading1 child' } );
 			} );
 
 			it( 'filters out disallowed elements and leaves out the text', () => {
@@ -661,6 +666,12 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<paragraph>foox<$text b="1">x</$text>x[]</paragraph>' );
 			} );
 
+			it( 'filters out disallowed attributes from nested child when merging', () => {
+				setData( doc, '<paragraph>f[]oo</paragraph>' );
+				insertHelper( '<heading1>x<child>b<$text a="1" b="1">a</$text>r</child>x</heading1>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>fx<child>b<$text b="1">a</$text>r</child>x[]oo</paragraph>' );
+			} );
+
 			it( 'filters out disallowed attributes when autoparagraphing', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<paragraph>xxx</paragraph><$text a="1" b="1">yyy</$text>' );

From 9cb061fb7e257a860546af08b761be199eb1f327 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Wed, 30 Aug 2017 14:24:23 +0200
Subject: [PATCH 24/32] Improved checking for attributes combinations.

---
 src/controller/deletecontent.js   | 23 ++++++++-----
 src/controller/insertcontent.js   | 55 +++++++++++++++----------------
 tests/controller/insertcontent.js | 10 +++---
 3 files changed, 47 insertions(+), 41 deletions(-)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index 1c6dcf015..e9162a351 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -74,7 +74,7 @@ export default function deleteContent( selection, batch, options = {} ) {
 		//
 		// e.g. bold is disallowed for <H1>
 		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
-		removeDisallowedAttributes( batch, Array.from( startPos.parent.getChildren() ), startPos );
+		removeDisallowedAttributes( Array.from( startPos.parent.getChildren() ), startPos, batch );
 	}
 
 	selection.setCollapsedAt( startPos );
@@ -228,21 +228,28 @@ function getNodeSchemaName( node ) {
 
 // Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes and its children.
 //
-// @param {module:engine/model/batch~Batch} batch Batch to which the deltas will be added.
-// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
 // @param {module:engine/model/schema~SchemaPath} schemaPath
-function removeDisallowedAttributes( batch, nodes, schemaPath ) {
+// @param {module:engine/model/batch~Batch} batch
+function removeDisallowedAttributes( nodes, schemaPath, batch ) {
 	const schema = batch.document.schema;
 
 	for ( const node of nodes ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
-				batch.removeAttribute( node, attribute );
+		const name = getNodeSchemaName( node );
+
+		// When node with attributes is not allowed in current position.
+		if ( !schema.check( { name, inside: schemaPath, attributes: Array.from( node.getAttributeKeys() ) } ) ) {
+			// Let's remove attributes one by one.
+			// This should be improved to check all combination of attributes.
+			for ( const attribute of node.getAttributeKeys() ) {
+				if ( !schema.check( { name, attributes: attribute, inside: schemaPath } ) ) {
+					batch.removeAttribute( node, attribute );
+				}
 			}
 		}
 
 		if ( node.is( 'element' ) ) {
-			removeDisallowedAttributes( batch, Array.from( node.getChildren() ), Position.createAt( node ) );
+			removeDisallowedAttributes( Array.from( node.getChildren() ), Position.createAt( node ), batch );
 		}
 	}
 }
diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index b8329ce4f..9424e92bf 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -229,7 +229,7 @@ class Insertion {
 		// If the node is a text and bare text is allowed in current position it means that the node
 		// contains disallowed attributes and we have to remove them.
 		else if ( this.schema.check( { name: '$text', inside: this.position } ) ) {
-			removeDisallowedAttributes( this.schema, [ node ], this.position );
+			removeDisallowedAttributes( [ node ], this.position, this.schema );
 			this._handleNode( node, context );
 		}
 		// If text is not allowed, try autoparagraphing.
@@ -290,7 +290,7 @@ class Insertion {
 
 			// We need to check and strip disallowed attributes in all nested nodes because after merge
 			// some attributes could end up in a path where are disallowed.
-			removeDisallowedAttributesOnBatch( this.batch, Array.from( this.position.parent.getChildren() ), position );
+			removeDisallowedAttributes( Array.from( position.parent.getChildren() ), position, this.schema, this.batch );
 
 			this.position = Position.createFromPosition( position );
 			position.detach();
@@ -317,7 +317,7 @@ class Insertion {
 
 			// We need to check and strip disallowed attributes in all nested nodes because after merge
 			// some attributes could end up in a place where are disallowed.
-			removeDisallowedAttributesOnBatch( this.batch, Array.from( this.position.parent.getChildren() ), position );
+			removeDisallowedAttributes( Array.from( position.parent.getChildren() ), position, this.schema, this.batch );
 
 			this.position = Position.createFromPosition( position );
 			position.detach();
@@ -343,7 +343,7 @@ class Insertion {
 			// When node is a text and is disallowed by schema it means that contains disallowed attributes
 			// and we need to remove them.
 			if ( node.is( 'text' ) && !this._checkIsAllowed( node, [ paragraph ] ) ) {
-				removeDisallowedAttributes( this.schema, [ node ], [ paragraph ] );
+				removeDisallowedAttributes( [ node ], [ paragraph ], this.schema );
 			}
 
 			if ( this._checkIsAllowed( node, [ paragraph ] ) ) {
@@ -447,38 +447,35 @@ function getNodeSchemaName( node ) {
 	return node.is( 'text' ) ? '$text' : node.name;
 }
 
-// Removes disallowed by schema attributes from given nodes.
+// Removes disallowed by schema attributes from given nodes. When batch parameter is provided then
+// attributes will be removed by adding deltas with `removeAttributes` operation to this batch
+// otherwise attributes will be removed directly from provided nodes.
 //
-// @param {module:engine/model/schema~Schema} schema
-// @param {Array<module:engine/model/node~Node>} nodes List of nodes to filter.
-// @param {module:engine/model/schema~SchemaPath} schemaPath
-function removeDisallowedAttributes( schema, nodes, schemaPath ) {
-	for ( const node of nodes ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
-				node.removeAttribute( attribute );
-			}
-		}
-	}
-}
-
-// Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes and its children.
-//
-// @param {module:engine/model/batch~Batch} batch Batch to which the deltas will be added.
-// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes List of nodes or a single node to filter.
+// @param {Array<module:engine/model/node~Node>} nodes
 // @param {module:engine/model/schema~SchemaPath} schemaPath
-function removeDisallowedAttributesOnBatch( batch, nodes, schemaPath ) {
-	const schema = batch.document.schema;
-
+// @param {module:engine/model/schema~Schema} schema
+// @param {module:engine/model/batch~Batch} [batch]
+function removeDisallowedAttributes( nodes, schemaPath, schema, batch ) {
 	for ( const node of nodes ) {
-		for ( const attribute of node.getAttributeKeys() ) {
-			if ( !schema.check( { name: getNodeSchemaName( node ), attributes: attribute, inside: schemaPath } ) ) {
-				batch.removeAttribute( node, attribute );
+		const name = getNodeSchemaName( node );
+
+		// When node with attributes is not allowed in current position.
+		if ( !schema.check( { name, inside: schemaPath, attributes: Array.from( node.getAttributeKeys() ) } ) ) {
+			// Let's remove attributes one by one.
+			// This should be improved to check all combination of attributes.
+			for ( const attribute of node.getAttributeKeys() ) {
+				if ( !schema.check( { name, inside: schemaPath, attributes: attribute } ) ) {
+					if ( batch ) {
+						batch.removeAttribute( node, attribute );
+					} else {
+						node.removeAttribute( attribute );
+					}
+				}
 			}
 		}
 
 		if ( node.is( 'element' ) ) {
-			removeDisallowedAttributesOnBatch( batch, Array.from( node.getChildren() ), Position.createAt( node ) );
+			removeDisallowedAttributes( Array.from( node.getChildren() ), Position.createAt( node ), schema, batch );
 		}
 	}
 }
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 95a1a7e95..439ced166 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -604,6 +604,7 @@ describe( 'DataController', () => {
 				schema.allow( { name: 'table', inside: '$clipboardHolder' } );
 				schema.allow( { name: 'td', inside: '$clipboardHolder' } );
 				schema.allow( { name: 'td', inside: 'table' } );
+				schema.allow( { name: 'child', inside: 'td' } );
 				schema.allow( { name: '$block', inside: 'td' } );
 				schema.allow( { name: '$text', inside: 'td' } );
 
@@ -616,6 +617,7 @@ describe( 'DataController', () => {
 				schema.allow( { name: '$text', attributes: 'b', inside: 'paragraph' } );
 				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'paragraph child' } );
 				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'heading1 child' } );
+				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'td child' } );
 			} );
 
 			it( 'filters out disallowed elements and leaves out the text', () => {
@@ -648,25 +650,25 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes when merging #1', () => {
+			it( 'filters out disallowed attributes after merge #1', () => {
 				setData( doc, '<paragraph>[]foo</paragraph>' );
 				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>x<$text b="1">x</$text>x[]foo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes when merging #2', () => {
+			it( 'filters out disallowed attributes after merge #2', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>x[]oo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes when merging #3', () => {
+			it( 'filters out disallowed attributes after merge #3', () => {
 				setData( doc, '<paragraph>foo[]</paragraph>' );
 				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>foox<$text b="1">x</$text>x[]</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes from nested child when merging', () => {
+			it( 'filters out disallowed attributes from nested elements after merge', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<heading1>x<child>b<$text a="1" b="1">a</$text>r</child>x</heading1>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<child>b<$text b="1">a</$text>r</child>x[]oo</paragraph>' );

From 5baf3e3293a80df0a226a1a7c794dd4646bd3a1c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Wed, 30 Aug 2017 17:43:45 +0200
Subject: [PATCH 25/32] Limit filtering only to a merged node.

---
 src/controller/insertcontent.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 9424e92bf..142870f57 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -290,7 +290,8 @@ class Insertion {
 
 			// We need to check and strip disallowed attributes in all nested nodes because after merge
 			// some attributes could end up in a path where are disallowed.
-			removeDisallowedAttributes( Array.from( position.parent.getChildren() ), position, this.schema, this.batch );
+			const parent = position.nodeBefore;
+			removeDisallowedAttributes( Array.from( parent.getChildren() ), Position.createAt( parent ), this.schema, this.batch );
 
 			this.position = Position.createFromPosition( position );
 			position.detach();

From ea3bc70712d1c0f6098f547bf06d69d4723d91ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Wed, 30 Aug 2017 21:37:59 +0200
Subject: [PATCH 26/32] Added filtering of nested elements after insert.

---
 src/controller/insertcontent.js   |  6 ++++++
 tests/controller/insertcontent.js | 35 ++++++++++++++++++-------------
 2 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 142870f57..3a1a149d4 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -326,6 +326,12 @@ class Insertion {
 
 		mergePosLeft.detach();
 		mergePosRight.detach();
+
+		// When there was no merge we need to check and strip disallowed attributes in all nested nodes of
+		// just inserted node because some attributes could end up in a place where are disallowed.
+		if ( !mergeLeft && !mergeRight ) {
+			removeDisallowedAttributes( Array.from( node.getChildren() ), Position.createAt( node ), this.schema, this.batch );
+		}
 	}
 
 	/**
diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 439ced166..89535472e 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -594,9 +594,8 @@ describe( 'DataController', () => {
 
 				schema.registerItem( 'paragraph', '$block' );
 				schema.registerItem( 'heading1', '$block' );
-				schema.registerItem( 'child', '$block' );
+				schema.registerItem( 'element', '$block' );
 
-				// Let's use table as an example of content which needs to be filtered out.
 				schema.registerItem( 'table' );
 				schema.registerItem( 'td' );
 				schema.registerItem( 'disallowedWidget' );
@@ -604,20 +603,22 @@ describe( 'DataController', () => {
 				schema.allow( { name: 'table', inside: '$clipboardHolder' } );
 				schema.allow( { name: 'td', inside: '$clipboardHolder' } );
 				schema.allow( { name: 'td', inside: 'table' } );
-				schema.allow( { name: 'child', inside: 'td' } );
+				schema.allow( { name: 'element', inside: 'td' } );
 				schema.allow( { name: '$block', inside: 'td' } );
 				schema.allow( { name: '$text', inside: 'td' } );
+				schema.allow( { name: 'table', inside: 'element' } );
 
 				schema.allow( { name: 'disallowedWidget', inside: '$clipboardHolder' } );
 				schema.allow( { name: '$text', inside: 'disallowedWidget' } );
 				schema.objects.add( 'disallowedWidget' );
 
-				schema.allow( { name: 'child', inside: 'paragraph' } );
-				schema.allow( { name: 'child', inside: 'heading1' } );
+				schema.allow( { name: 'element', inside: 'paragraph' } );
+				schema.allow( { name: 'element', inside: 'heading1' } );
 				schema.allow( { name: '$text', attributes: 'b', inside: 'paragraph' } );
-				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'paragraph child' } );
-				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'heading1 child' } );
-				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'td child' } );
+				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'paragraph element' } );
+				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'heading1 element' } );
+				schema.allow( { name: '$text', attributes: [ 'a', 'b' ], inside: 'td element' } );
+				schema.allow( { name: '$text', attributes: [ 'b' ], inside: 'element table td' } );
 			} );
 
 			it( 'filters out disallowed elements and leaves out the text', () => {
@@ -644,34 +645,40 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
 			} );
 
+			it( 'filters out disallowed attributes when inserting nested elements', () => {
+				setData( doc, '<element>[]</element>' );
+				insertHelper( '<table><td>f<$text a="1" b="1" c="1">o</$text>o</td></table>' );
+				expect( getData( doc ) ).to.equal( '<element><table><td>f<$text b="1">o</$text>o</td></table>[]</element>' );
+			} );
+
 			it( 'filters out disallowed attributes when inserting text in disallowed elements', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<table><td>x<$text a="1" b="1">x</$text>x</td><td>y<$text a="1">y</$text>y</td></table>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>xyyy[]oo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes after merge #1', () => {
+			it( 'filters out disallowed attributes when merging #1', () => {
 				setData( doc, '<paragraph>[]foo</paragraph>' );
 				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>x<$text b="1">x</$text>x[]foo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes after merge #2', () => {
+			it( 'filters out disallowed attributes when merging #2', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<$text b="1">x</$text>x[]oo</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes after merge #3', () => {
+			it( 'filters out disallowed attributes when merging #3', () => {
 				setData( doc, '<paragraph>foo[]</paragraph>' );
 				insertHelper( '<paragraph>x<$text a="1" b="1">x</$text>x</paragraph>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>foox<$text b="1">x</$text>x[]</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes from nested elements after merge', () => {
+			it( 'filters out disallowed attributes from nested nodes after merge', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
-				insertHelper( '<heading1>x<child>b<$text a="1" b="1">a</$text>r</child>x</heading1>' );
-				expect( getData( doc ) ).to.equal( '<paragraph>fx<child>b<$text b="1">a</$text>r</child>x[]oo</paragraph>' );
+				insertHelper( '<heading1>x<element>b<$text a="1" b="1">a</$text>r</element>x</heading1>' );
+				expect( getData( doc ) ).to.equal( '<paragraph>fx<element>b<$text b="1">a</$text>r</element>x[]oo</paragraph>' );
 			} );
 
 			it( 'filters out disallowed attributes when autoparagraphing', () => {

From 479a4217af90d9a12941fb263f877b1a58a9f143 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Wed, 30 Aug 2017 21:38:22 +0200
Subject: [PATCH 27/32] Added manual test for filtering attributes.

---
 tests/manual/tickets/1088/1.html | 23 +++++++++++++++++++++++
 tests/manual/tickets/1088/1.js   | 29 +++++++++++++++++++++++++++++
 tests/manual/tickets/1088/1.md   | 20 ++++++++++++++++++++
 3 files changed, 72 insertions(+)
 create mode 100644 tests/manual/tickets/1088/1.html
 create mode 100644 tests/manual/tickets/1088/1.js
 create mode 100644 tests/manual/tickets/1088/1.md

diff --git a/tests/manual/tickets/1088/1.html b/tests/manual/tickets/1088/1.html
new file mode 100644
index 000000000..e2e064e77
--- /dev/null
+++ b/tests/manual/tickets/1088/1.html
@@ -0,0 +1,23 @@
+<div style="padding: 20px;">
+	<div id="editor">
+		<h2>Heading 1 (disallowed: link)</h2>
+		<p>This is a paragraph</p>
+		<h3>Heading 2 (disallowed: italic)</h3>
+		<p></p>
+		<blockquote>
+			<p>This is a paragraph in a blockQuote</p>
+			<p></p>
+		</blockquote>
+		<h4>Heading 3 (disallowed: italic, link)</h4>
+	</div>
+
+	<div>
+		<p><a href="https://ckeditor.com"><i>Paragraph with link and italic</i></a></p>
+
+		<ul>
+			<li><a href="https://ckeditor.com"><b>List item with link and bold</b></a></li>
+		</ul>
+
+		<div><b>Just a text with bold</b></div>
+	</div>
+</div>
diff --git a/tests/manual/tickets/1088/1.js b/tests/manual/tickets/1088/1.js
new file mode 100644
index 000000000..0195e6a43
--- /dev/null
+++ b/tests/manual/tickets/1088/1.js
@@ -0,0 +1,29 @@
+/**
+ * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+/* globals console, window, document */
+
+import ClassicEditor from '@ckeditor/ckeditor5-editor-classic/src/classiceditor';
+import ArticlePreset from '@ckeditor/ckeditor5-presets/src/article';
+
+ClassicEditor
+	.create( document.querySelector( '#editor' ), {
+		plugins: [ ArticlePreset ],
+		toolbar: [ 'headings', 'undo', 'redo' ]
+	} )
+	.then( editor => {
+		window.editor = editor;
+
+		const schema = editor.document.schema;
+
+		schema.disallow( { name: '$text', attributes: [ 'linkHref' ], inside: 'heading1' } );
+		schema.disallow( { name: '$text', attributes: [ 'italic' ], inside: 'heading2' } );
+		schema.disallow( { name: '$text', attributes: [ 'italic', 'linkHref' ], inside: 'heading3' } );
+		schema.disallow( { name: '$text', attributes: [ 'bold' ], inside: 'paragraph' } );
+		schema.disallow( { name: '$text', attributes: [ 'bold', 'linkHref' ], inside: 'blockQuote listItem' } );
+	} )
+	.catch( err => {
+		console.error( err.stack );
+	} );
diff --git a/tests/manual/tickets/1088/1.md b/tests/manual/tickets/1088/1.md
new file mode 100644
index 000000000..747c17cfe
--- /dev/null
+++ b/tests/manual/tickets/1088/1.md
@@ -0,0 +1,20 @@
+## Stripping disallowed attributes by `(insert|delete)Content` [#1088](https://github.com/ckeditor/ckeditor5-engine/issues/1088)
+
+### Simple scenario.
+
+1. Copy a paragraph with italic and link.
+2. Paste it to the Heading 1. Inserted text should have only an italic style.
+3. Paste it to the Heading 2. Inserted text should have only a link.
+4. Paste it to the Heading 3. Inserted text should be fully stripped.
+
+### Nested nodes.
+
+1. Copy a list item with bold and link.
+2. Paste it into the empty block (just under the Heading 2). Inserted list item should have a bold style a link.
+2. Paste it into the empty block in BlockQuote. Inserted list item should be fully stripped.
+
+### Auto paragraphing.
+
+1. Copy a text with bold.
+2. Select all content in the editor.
+3. Paste copied text. Inserted content should be a paragraph and should be stripped from bold.

From cd6cd0bdde1555ce137fe25128d505431d3dd9c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Wed, 30 Aug 2017 21:55:09 +0200
Subject: [PATCH 28/32] Changed test name.

---
 tests/controller/insertcontent.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/controller/insertcontent.js b/tests/controller/insertcontent.js
index 89535472e..06ad07961 100644
--- a/tests/controller/insertcontent.js
+++ b/tests/controller/insertcontent.js
@@ -675,7 +675,7 @@ describe( 'DataController', () => {
 				expect( getData( doc ) ).to.equal( '<paragraph>foox<$text b="1">x</$text>x[]</paragraph>' );
 			} );
 
-			it( 'filters out disallowed attributes from nested nodes after merge', () => {
+			it( 'filters out disallowed attributes from nested nodes when merging', () => {
 				setData( doc, '<paragraph>f[]oo</paragraph>' );
 				insertHelper( '<heading1>x<element>b<$text a="1" b="1">a</$text>r</element>x</heading1>' );
 				expect( getData( doc ) ).to.equal( '<paragraph>fx<element>b<$text b="1">a</$text>r</element>x[]oo</paragraph>' );

From 5bb12e2f74cb0a3f50e8a24617416b4df69a235f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Fri, 1 Sep 2017 09:58:18 +0200
Subject: [PATCH 29/32] Remove unnecessary transformation to array.

---
 src/controller/deletecontent.js | 4 ++--
 src/controller/insertcontent.js | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index e9162a351..559645941 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -74,7 +74,7 @@ export default function deleteContent( selection, batch, options = {} ) {
 		//
 		// e.g. bold is disallowed for <H1>
 		// <h1>Fo{o</h1><p>b}a<b>r</b><p> -> <h1>Fo{}a<b>r</b><h1> -> <h1>Fo{}ar<h1>.
-		removeDisallowedAttributes( Array.from( startPos.parent.getChildren() ), startPos, batch );
+		removeDisallowedAttributes( startPos.parent.getChildren(), startPos, batch );
 	}
 
 	selection.setCollapsedAt( startPos );
@@ -249,7 +249,7 @@ function removeDisallowedAttributes( nodes, schemaPath, batch ) {
 		}
 
 		if ( node.is( 'element' ) ) {
-			removeDisallowedAttributes( Array.from( node.getChildren() ), Position.createAt( node ), batch );
+			removeDisallowedAttributes( node.getChildren(), Position.createAt( node ), batch );
 		}
 	}
 }
diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 3a1a149d4..6d6db7913 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -291,7 +291,7 @@ class Insertion {
 			// We need to check and strip disallowed attributes in all nested nodes because after merge
 			// some attributes could end up in a path where are disallowed.
 			const parent = position.nodeBefore;
-			removeDisallowedAttributes( Array.from( parent.getChildren() ), Position.createAt( parent ), this.schema, this.batch );
+			removeDisallowedAttributes( parent.getChildren(), Position.createAt( parent ), this.schema, this.batch );
 
 			this.position = Position.createFromPosition( position );
 			position.detach();
@@ -318,7 +318,7 @@ class Insertion {
 
 			// We need to check and strip disallowed attributes in all nested nodes because after merge
 			// some attributes could end up in a place where are disallowed.
-			removeDisallowedAttributes( Array.from( position.parent.getChildren() ), position, this.schema, this.batch );
+			removeDisallowedAttributes( position.parent.getChildren(), position, this.schema, this.batch );
 
 			this.position = Position.createFromPosition( position );
 			position.detach();
@@ -330,7 +330,7 @@ class Insertion {
 		// When there was no merge we need to check and strip disallowed attributes in all nested nodes of
 		// just inserted node because some attributes could end up in a place where are disallowed.
 		if ( !mergeLeft && !mergeRight ) {
-			removeDisallowedAttributes( Array.from( node.getChildren() ), Position.createAt( node ), this.schema, this.batch );
+			removeDisallowedAttributes( node.getChildren(), Position.createAt( node ), this.schema, this.batch );
 		}
 	}
 
@@ -482,7 +482,7 @@ function removeDisallowedAttributes( nodes, schemaPath, schema, batch ) {
 		}
 
 		if ( node.is( 'element' ) ) {
-			removeDisallowedAttributes( Array.from( node.getChildren() ), Position.createAt( node ), schema, batch );
+			removeDisallowedAttributes( node.getChildren(), Position.createAt( node ), schema, batch );
 		}
 	}
 }

From c572b110797a4216e1c2377d39576e212a6c3487 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Fri, 1 Sep 2017 10:00:42 +0200
Subject: [PATCH 30/32] Changed docs.

---
 src/controller/deletecontent.js | 14 +++++++-------
 src/controller/insertcontent.js | 18 +++++++++---------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/controller/deletecontent.js b/src/controller/deletecontent.js
index 559645941..7a9a91e32 100644
--- a/src/controller/deletecontent.js
+++ b/src/controller/deletecontent.js
@@ -226,23 +226,23 @@ function getNodeSchemaName( node ) {
 	return node.is( 'text' ) ? '$text' : node.name;
 }
 
-// Adds deltas with `removeAttributes` operation for disallowed by schema attributes on given nodes and its children.
+// Creates AttributeDeltas that removes attributes that are disallowed by schema on given node and its children.
 //
-// @param {module:engine/model/node~Node|Array<module:engine/model/node~Node>} nodes
-// @param {module:engine/model/schema~SchemaPath} schemaPath
-// @param {module:engine/model/batch~Batch} batch
-function removeDisallowedAttributes( nodes, schemaPath, batch ) {
+// @param {Array<module:engine/model/node~Node>} nodes Nodes that will be filtered.
+// @param {module:engine/model/schema~SchemaPath} inside Path inside which schema will be checked.
+// @param {module:engine/model/batch~Batch} batch Batch to which the deltas will be added.
+function removeDisallowedAttributes( nodes, inside, batch ) {
 	const schema = batch.document.schema;
 
 	for ( const node of nodes ) {
 		const name = getNodeSchemaName( node );
 
 		// When node with attributes is not allowed in current position.
-		if ( !schema.check( { name, inside: schemaPath, attributes: Array.from( node.getAttributeKeys() ) } ) ) {
+		if ( !schema.check( { name, inside, attributes: Array.from( node.getAttributeKeys() ) } ) ) {
 			// Let's remove attributes one by one.
 			// This should be improved to check all combination of attributes.
 			for ( const attribute of node.getAttributeKeys() ) {
-				if ( !schema.check( { name, attributes: attribute, inside: schemaPath } ) ) {
+				if ( !schema.check( { name, inside, attributes: attribute } ) ) {
 					batch.removeAttribute( node, attribute );
 				}
 			}
diff --git a/src/controller/insertcontent.js b/src/controller/insertcontent.js
index 6d6db7913..c8e24150e 100644
--- a/src/controller/insertcontent.js
+++ b/src/controller/insertcontent.js
@@ -455,23 +455,23 @@ function getNodeSchemaName( node ) {
 }
 
 // Removes disallowed by schema attributes from given nodes. When batch parameter is provided then
-// attributes will be removed by adding deltas with `removeAttributes` operation to this batch
-// otherwise attributes will be removed directly from provided nodes.
+// attributes will be removed by creating AttributeDeltas otherwise attributes will be removed
+// directly from provided nodes.
 //
-// @param {Array<module:engine/model/node~Node>} nodes
-// @param {module:engine/model/schema~SchemaPath} schemaPath
-// @param {module:engine/model/schema~Schema} schema
-// @param {module:engine/model/batch~Batch} [batch]
-function removeDisallowedAttributes( nodes, schemaPath, schema, batch ) {
+// @param {Array<module:engine/model/node~Node>} nodes Nodes that will be filtered.
+// @param {module:engine/model/schema~SchemaPath} inside Path inside which schema will be checked.
+// @param {module:engine/model/schema~Schema} schema Schema instance uses for element validation.
+// @param {module:engine/model/batch~Batch} [batch] Batch to which the deltas will be added.
+function removeDisallowedAttributes( nodes, inside, schema, batch ) {
 	for ( const node of nodes ) {
 		const name = getNodeSchemaName( node );
 
 		// When node with attributes is not allowed in current position.
-		if ( !schema.check( { name, inside: schemaPath, attributes: Array.from( node.getAttributeKeys() ) } ) ) {
+		if ( !schema.check( { name, inside, attributes: Array.from( node.getAttributeKeys() ) } ) ) {
 			// Let's remove attributes one by one.
 			// This should be improved to check all combination of attributes.
 			for ( const attribute of node.getAttributeKeys() ) {
-				if ( !schema.check( { name, inside: schemaPath, attributes: attribute } ) ) {
+				if ( !schema.check( { name, inside, attributes: attribute } ) ) {
 					if ( batch ) {
 						batch.removeAttribute( node, attribute );
 					} else {

From 109db2e216d380e17c7ac68495b019e186281c5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oskar=20Wr=C3=B3bel?= <kontakt@oskarwrobel.pl>
Date: Fri, 1 Sep 2017 12:30:08 +0200
Subject: [PATCH 31/32] Imroved manual test for filtering nodes.

---
 tests/manual/tickets/1088/1.html     |   9 +++++++--
 tests/manual/tickets/1088/1.js       |  15 +++++++++------
 tests/manual/tickets/1088/1.md       |  20 +++++++++++++++-----
 tests/manual/tickets/1088/sample.jpg | Bin 0 -> 114298 bytes
 4 files changed, 31 insertions(+), 13 deletions(-)
 create mode 100644 tests/manual/tickets/1088/sample.jpg

diff --git a/tests/manual/tickets/1088/1.html b/tests/manual/tickets/1088/1.html
index e2e064e77..647ee42c9 100644
--- a/tests/manual/tickets/1088/1.html
+++ b/tests/manual/tickets/1088/1.html
@@ -1,6 +1,6 @@
 <div style="padding: 20px;">
 	<div id="editor">
-		<h2>Heading 1 (disallowed: link)</h2>
+		<h2>Heading 1 (disallowed: italic, link)</h2>
 		<p>This is a paragraph</p>
 		<h3>Heading 2 (disallowed: italic)</h3>
 		<p></p>
@@ -8,7 +8,6 @@ <h3>Heading 2 (disallowed: italic)</h3>
 			<p>This is a paragraph in a blockQuote</p>
 			<p></p>
 		</blockquote>
-		<h4>Heading 3 (disallowed: italic, link)</h4>
 	</div>
 
 	<div>
@@ -18,6 +17,12 @@ <h4>Heading 3 (disallowed: italic, link)</h4>
 			<li><a href="https://ckeditor.com"><b>List item with link and bold</b></a></li>
 		</ul>
 
+		<h4><b>Heading 3 with bold</b></h4>
+
 		<div><b>Just a text with bold</b></div>
+
+		<br>
+
+		<img src="sample.jpg" alt="Sample image" height="150">
 	</div>
 </div>
diff --git a/tests/manual/tickets/1088/1.js b/tests/manual/tickets/1088/1.js
index 0195e6a43..3f333da74 100644
--- a/tests/manual/tickets/1088/1.js
+++ b/tests/manual/tickets/1088/1.js
@@ -6,23 +6,26 @@
 /* globals console, window, document */
 
 import ClassicEditor from '@ckeditor/ckeditor5-editor-classic/src/classiceditor';
-import ArticlePreset from '@ckeditor/ckeditor5-presets/src/article';
+import ArticlePresets from '@ckeditor/ckeditor5-presets/src/article';
 
 ClassicEditor
 	.create( document.querySelector( '#editor' ), {
-		plugins: [ ArticlePreset ],
-		toolbar: [ 'headings', 'undo', 'redo' ]
+		plugins: [ ArticlePresets ],
+		toolbar: [ 'headings', 'undo', 'redo' ],
+		image: {
+			toolbar: [ 'imageTextAlternative' ]
+		}
 	} )
 	.then( editor => {
 		window.editor = editor;
 
 		const schema = editor.document.schema;
 
-		schema.disallow( { name: '$text', attributes: [ 'linkHref' ], inside: 'heading1' } );
+		schema.disallow( { name: '$text', attributes: [ 'linkHref', 'italic' ], inside: 'heading1' } );
 		schema.disallow( { name: '$text', attributes: [ 'italic' ], inside: 'heading2' } );
-		schema.disallow( { name: '$text', attributes: [ 'italic', 'linkHref' ], inside: 'heading3' } );
+		schema.disallow( { name: '$text', attributes: [ 'linkHref' ], inside: 'blockQuote listItem' } );
 		schema.disallow( { name: '$text', attributes: [ 'bold' ], inside: 'paragraph' } );
-		schema.disallow( { name: '$text', attributes: [ 'bold', 'linkHref' ], inside: 'blockQuote listItem' } );
+		schema.disallow( { name: 'heading3', inside: '$root' } );
 	} )
 	.catch( err => {
 		console.error( err.stack );
diff --git a/tests/manual/tickets/1088/1.md b/tests/manual/tickets/1088/1.md
index 747c17cfe..341b1f9c5 100644
--- a/tests/manual/tickets/1088/1.md
+++ b/tests/manual/tickets/1088/1.md
@@ -3,18 +3,28 @@
 ### Simple scenario.
 
 1. Copy a paragraph with italic and link.
-2. Paste it to the Heading 1. Inserted text should have only an italic style.
-3. Paste it to the Heading 2. Inserted text should have only a link.
-4. Paste it to the Heading 3. Inserted text should be fully stripped.
+2. Paste it to the Heading 1. Inserted text should be not stripped.
+3. Paste it to the Heading 2. Inserted text should be a link only.
+
+### Simple scenario (element).
+
+1. Copy image.
+2. Paste it to the editor. Image should be inserted with an alternative text "Sample image".
 
 ### Nested nodes.
 
 1. Copy a list item with bold and link.
-2. Paste it into the empty block (just under the Heading 2). Inserted list item should have a bold style a link.
-2. Paste it into the empty block in BlockQuote. Inserted list item should be fully stripped.
+2. Paste it into the empty block (directly to the root) . Inserted list item should be a bold link.
+2. Paste it into the empty block in BlockQuote. Inserted list item should be a bold only.
 
 ### Auto paragraphing.
 
 1. Copy a text with bold.
 2. Select all content in the editor.
 3. Paste copied text. Inserted content should be a paragraph and should be stripped from bold.
+
+### Auto paragraphing (disallowed block).
+
+1. Copy Heading 3 with bold
+2. Select all content in the editor.
+3. Paste copied text. Inserted content should be a paragraph and should be stripped from bold.
diff --git a/tests/manual/tickets/1088/sample.jpg b/tests/manual/tickets/1088/sample.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b77d07e7bfff7fed1563fe2cd190c46ade02905f
GIT binary patch
literal 114298
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%0AJpB30>xrtz6
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

literal 0
HcmV?d00001


From e592d2d59f904ead6d2ca0dcf73518835740f1e6 Mon Sep 17 00:00:00 2001
From: Szymon Cofalik <s.cofalik@cksource.com>
Date: Fri, 1 Sep 2017 15:12:19 +0200
Subject: [PATCH 32/32] Tests: Improved manual test.

---
 tests/manual/tickets/1088/1.html | 2 +-
 tests/manual/tickets/1088/1.md   | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/manual/tickets/1088/1.html b/tests/manual/tickets/1088/1.html
index 647ee42c9..efcb091f2 100644
--- a/tests/manual/tickets/1088/1.html
+++ b/tests/manual/tickets/1088/1.html
@@ -17,7 +17,7 @@ <h3>Heading 2 (disallowed: italic)</h3>
 			<li><a href="https://ckeditor.com"><b>List item with link and bold</b></a></li>
 		</ul>
 
-		<h4><b>Heading 3 with bold</b></h4>
+		<h4><b><i>Heading 3 with bold and italic</i></b></h4>
 
 		<div><b>Just a text with bold</b></div>
 
diff --git a/tests/manual/tickets/1088/1.md b/tests/manual/tickets/1088/1.md
index 341b1f9c5..0acf53214 100644
--- a/tests/manual/tickets/1088/1.md
+++ b/tests/manual/tickets/1088/1.md
@@ -3,8 +3,9 @@
 ### Simple scenario.
 
 1. Copy a paragraph with italic and link.
-2. Paste it to the Heading 1. Inserted text should be not stripped.
+2. Paste it to the Heading 1. Inserted text should be stripped
 3. Paste it to the Heading 2. Inserted text should be a link only.
+4. Paste it to paragraph. Inserted text should not be stripped.
 
 ### Simple scenario (element).
 
@@ -25,6 +26,6 @@
 
 ### Auto paragraphing (disallowed block).
 
-1. Copy Heading 3 with bold
+1. Copy Heading 3 with bold and italic.
 2. Select all content in the editor.
 3. Paste copied text. Inserted content should be a paragraph and should be stripped from bold.