Add insertObject() function.

packages/ckeditor5-engine/src/model/model.js

@@ -27,6 +27,7 @@ import getSelectedContent from './utils/getselectedcontent';
 import { injectSelectionPostFixer } from './utils/selection-post-fixer';
 import { autoParagraphEmptyRoots } from './utils/autoparagraphing';
 import CKEditorError from '@ckeditor/ckeditor5-utils/src/ckeditorerror';
+import insertObject from '@ckeditor/ckeditor5-widget/src/insertobject';
 
 // @if CK_DEBUG_ENGINE // const { dumpTrees } = require( '../dev-utils/utils' );
 // @if CK_DEBUG_ENGINE // const { OperationReplayer } = require( '../dev-utils/operationreplayer' ).default;
@@ -452,6 +453,21 @@ export default class Model {
 		return insertContent( this, content, selectable, placeOrOffset );
 	}
 
+	/*
+		Place for exceptional documentation
+		Object - an object that we would like to insert
+		Selectable - 99% - document selection, but sometimes custom one.
+		Offset - just to pass to insert content
+		Options -     	setSelection: 'on|in|after',
+						findOptimalPosition: true,
+						// Maybe:
+						doNotInheritBlockAttributes: true
+	*/
+	insertObject( object, selectable, offset, options ) {
+		// TODO: Get rid of import from widget package, so engine does not depend on it.
+		return insertObject( this, object, selectable, offset, options );
+	}
+
 	/**
 	 * Deletes content of the selection and merge siblings. The resulting selection is always collapsed.
 	 *

packages/ckeditor5-engine/src/model/schema.js

@@ -863,6 +863,28 @@ export default class Schema {
 		}
 	}
 
+	// TODO: API DOCS
+	getAttributesWithProperty( node, propertyName, propertyValue ) {
+		const attributes = {};
+
+		if ( !node ) {
+			return attributes;
+		}
+
+		const nodeAttributes = node.getAttributes();
+
+		for ( const [ attributeName, attributeValue ] of nodeAttributes ) {
+			const attributeProperties = this.getAttributeProperties( attributeName );
+			const isPropertyValueValid = ( !propertyValue || attributeProperties[ propertyName ] === propertyValue );
+
+			if ( attributeProperties[ propertyName ] && isPropertyValueValid ) {
+				attributes[ attributeName ] = attributeValue;
+			}
+		}
+
+		return attributes;
+	}
+
 	/**
 	 * Creates an instance of the schema context.
 	 *

packages/ckeditor5-engine/src/model/utils/deletecontent.js

@@ -114,7 +114,10 @@ export default function deleteContent( model, selection, options = {} ) {
 		// Check if a text is allowed in the new container. If not, try to create a new paragraph (if it's allowed here).
 		// If autoparagraphing is off, we assume that you know what you do so we leave the selection wherever it was.
 		if ( !options.doNotAutoparagraph && shouldAutoparagraph( schema, startPosition ) ) {
-			insertParagraph( writer, startPosition, selection );
+			const selectedElement = selection.getSelectedElement();
+			const attributesToCopy = schema.getAttributesWithProperty( selectedElement, 'copyOnReplace', true );
+
+			insertParagraph( writer, startPosition, selection, attributesToCopy );
 		}
 
 		startPosition.detach();
@@ -482,8 +485,8 @@ function isCrossingLimitElement( leftPos, rightPos, schema ) {
 	return true;
 }
 
-function insertParagraph( writer, position, selection ) {
-	const paragraph = writer.createElement( 'paragraph' );
+function insertParagraph( writer, position, selection, attributes ) {
+	const paragraph = writer.createElement( 'paragraph', attributes );
 
 	writer.insert( paragraph, position );
 

packages/ckeditor5-horizontal-line/src/horizontallinecommand.js

@@ -44,24 +44,12 @@ export default class HorizontalLineCommand extends Command {
 		model.change( writer => {
 			const horizontalElement = writer.createElement( 'horizontalLine' );
 
-			model.insertContent( horizontalElement );
-
-			let nextElement = horizontalElement.nextSibling;
-
-			// Check whether an element next to the inserted horizontal line is defined and can contain a text.
-			const canSetSelection = nextElement && model.schema.checkChild( nextElement, '$text' );
-
-			// If the element is missing, but a paragraph could be inserted next to the horizontal line, let's add it.
-			if ( !canSetSelection && model.schema.checkChild( horizontalElement.parent, 'paragraph' ) ) {
-				nextElement = writer.createElement( 'paragraph' );
-
-				model.insertContent( nextElement, writer.createPositionAfter( horizontalElement ) );
-			}
-
-			// Put the selection inside the element, at the beginning.
-			if ( nextElement ) {
-				writer.setSelection( nextElement, 0 );
-			}
+			model.insertObject(
+				horizontalElement,
+				undefined,
+				undefined,
+				{ setSelection: 'after' }
+			);
 		} );
 	}
 }

packages/ckeditor5-horizontal-line/tests/horizontallinecommand.js

@@ -300,5 +300,72 @@ describe( 'HorizontalLineCommand', () => {
 				'<paragraph>foo</paragraph><horizontalLine></horizontalLine><paragraph>[]bar</paragraph>'
 			);
 		} );
+
+		describe( 'inheriting attributes', () => {
+			beforeEach( () => {
+				const attributes = [ 'smart', 'pretty' ];
+
+				model.schema.extend( '$block', {
+					allowAttributes: attributes
+				} );
+
+				model.schema.extend( '$blockObject', {
+					allowAttributes: attributes
+				} );
+
+				for ( const attribute of attributes ) {
+					model.schema.setAttributeProperties( attribute, {
+						copyOnReplace: true
+					} );
+				}
+			} );
+
+			it( 'should copy $block attributes on a horizontal line element when inserting it in $block', () => {
+				setModelData( model, '<paragraph pretty="true" smart="true">[]</paragraph>' );
+
+				command.execute();
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'<horizontalLine pretty="true" smart="true"></horizontalLine>' +
+					'<paragraph>[]</paragraph>'
+				);
+			} );
+
+			it( 'should copy attributes from first selected element', () => {
+				setModelData( model, '<paragraph pretty="true">[foo</paragraph><paragraph smart="true">bar]</paragraph>' );
+
+				command.execute();
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'<horizontalLine pretty="true"></horizontalLine>' +
+					'<paragraph>[]</paragraph>'
+				);
+			} );
+
+			it( 'should only copy $block attributes marked with copyOnReplace', () => {
+				setModelData( model, '<paragraph pretty="true" smart="true" nice="true">[]</paragraph>' );
+
+				command.execute();
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'<horizontalLine pretty="true" smart="true"></horizontalLine>' +
+					'<paragraph>[]</paragraph>'
+				);
+			} );
+
+			it( 'should copy attributes from object when it is selected during insertion', () => {
+				model.schema.register( 'object', { isObject: true, inheritAllFrom: '$blockObject' } );
+				editor.conversion.for( 'downcast' ).elementToElement( { model: 'object', view: 'object' } );
+
+				setModelData( model, '[<object pretty="true" smart="true"></object>]' );
+
+				command.execute();
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'<horizontalLine pretty="true" smart="true"></horizontalLine>' +
+					'<paragraph>[]</paragraph>'
+				);
+			} );
+		} );
 	} );
 } );

packages/ckeditor5-html-embed/src/htmlembedcommand.js

@@ -65,8 +65,12 @@ export default class HtmlEmbedCommand extends Command {
 			} else {
 				htmlEmbedElement = writer.createElement( 'rawHtml' );
 
-				model.insertContent( htmlEmbedElement );
-				writer.setSelection( htmlEmbedElement, 'on' );
+				model.insertObject(
+					htmlEmbedElement,
+					undefined,
+					undefined,
+					{ setSelection: 'on' }
+				);
 			}
 
 			writer.setAttribute( 'value', value, htmlEmbedElement );

packages/ckeditor5-html-embed/tests/htmlembedcommand.js

@@ -253,5 +253,68 @@ describe( 'HtmlEmbedCommand', () => {
 				expect( model.document.getRoot().getChild( 0 ) ).to.equal( initialEmbedElement );
 			} );
 		} );
+
+		describe( 'inheriting attributes', () => {
+			beforeEach( () => {
+				const attributes = [ 'smart', 'pretty' ];
+
+				model.schema.extend( '$block', {
+					allowAttributes: attributes
+				} );
+
+				model.schema.extend( '$blockObject', {
+					allowAttributes: attributes
+				} );
+
+				for ( const attribute of attributes ) {
+					model.schema.setAttributeProperties( attribute, {
+						copyOnReplace: true
+					} );
+				}
+			} );
+
+			it( 'should copy $block attributes on a html embed element when inserting it in $block', () => {
+				setModelData( model, '<paragraph pretty="true" smart="true">[]</paragraph>' );
+
+				command.execute( '<b>Foo.</b>' );
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'[<rawHtml pretty="true" smart="true" value="<b>Foo.</b>"></rawHtml>]'
+				);
+			} );
+
+			it( 'should copy attributes from first selected element', () => {
+				setModelData( model, '<paragraph pretty="true">[foo</paragraph><paragraph smart="true">bar]</paragraph>' );
+
+				command.execute( '<b>Foo.</b>' );
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'[<rawHtml pretty="true" value="<b>Foo.</b>"></rawHtml>]'
+				);
+			} );
+
+			it( 'should only copy $block attributes marked with copyOnReplace', () => {
+				setModelData( model, '<paragraph pretty="true" smart="true" nice="true">[]</paragraph>' );
+
+				command.execute( '<b>Foo.</b>' );
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'[<rawHtml pretty="true" smart="true" value="<b>Foo.</b>"></rawHtml>]'
+				);
+			} );
+
+			it( 'should copy attributes from object when it is selected during insertion', () => {
+				model.schema.register( 'object', { isObject: true, inheritAllFrom: '$blockObject' } );
+				editor.conversion.for( 'downcast' ).elementToElement( { model: 'object', view: 'object' } );
+
+				setModelData( model, '[<object pretty="true" smart="true"></object>]' );
+
+				command.execute( '<b>Foo.</b>' );
+
+				expect( getModelData( model ) ).to.equalMarkup(
+					'[<rawHtml pretty="true" smart="true" value="<b>Foo.</b>"></rawHtml>]'
+				);
+			} );
+		} );
 	} );
 } );

packages/ckeditor5-image/src/imageutils.js

@@ -103,18 +103,20 @@ export default class ImageUtils extends Plugin {
 		return model.change( writer => {
 			const imageElement = writer.createElement( imageType, attributes );
 
-			// If we want to insert a block image (for whatever reason) then we don't want to split text blocks.
-			// This applies only when we don't have the selectable specified (i.e., we insert multiple block images at once).
-			if ( !selectable && imageType != 'imageInline' ) {
-				selectable = findOptimalInsertionRange( selection, model );
-			}
-
-			model.insertContent( imageElement, selectable );
+			model.insertObject(
+				imageElement,
+				selectable,
+				undefined,
+				{
+					setSelection: 'on',
+					// If we want to insert a block image (for whatever reason) then we don't want to split text blocks.
+					// This applies only when we don't have the selectable specified (i.e., we insert multiple block images at once).
+					findOptimalPosition: !selectable && imageType != 'imageInline'
+				}
+			);
 
 			// Inserting an image might've failed due to schema regulations.
 			if ( imageElement.parent ) {
-				writer.setSelection( imageElement, 'on' );
-
 				return imageElement;
 			}
 

packages/ckeditor5-image/tests/image/imagetypecommand.js

@@ -671,5 +671,46 @@ describe( 'ImageTypeCommand', () => {
 				setModelData( model, `[<imageBlock src="${ imgSrc }"><caption>foo</caption></imageBlock>]` );
 			} );
 		} );
+
+		describe( 'inheriting attributes', () => {
+			const imgSrc = '/foo.jpg';
+
+			beforeEach( () => {
+				const attributes = [ 'smart', 'pretty' ];
+
+				model.schema.extend( '$block', {
+					allowAttributes: attributes
+				} );
+
+				model.schema.extend( '$blockObject', {
+					allowAttributes: attributes
+				} );
+
+				for ( const attribute of attributes ) {
+					model.schema.setAttributeProperties( attribute, {
+						copyOnReplace: true
+					} );
+				}
+			} );
+
+			it( 'should copy parent block attributes to image block', () => {
+				setModelData( model, `<paragraph pretty="true" smart="true">[<imageInline src="${ imgSrc }"></imageInline>]</paragraph>` );
+
+				blockCommand.execute();
+
+				expect( getModelData( model ) ).to.equal( `[<imageBlock pretty="true" smart="true" src="${ imgSrc }"></imageBlock>]` );
+			} );
+
+			it( 'should copy a block image attributes to an inline image\'s parent block', () => {
+				setModelData( model, `[<imageBlock pretty="true" smart="true" src="${ imgSrc }"></imageBlock>]` );
+
+				inlineCommand.execute();
+
+				expect( getModelData( model ) ).to.equal(
+					'<paragraph pretty="true" smart="true">' +
+						`[<imageInline src="${ imgSrc }"></imageInline>]` +
+					'</paragraph>' );
+			} );
+		} );
 	} );
 } );