Explorar o código

Merge pull request #249 from ckeditor/t/244

t/224: Rename TreeView.Converter to TreeView.DomConverter.
Piotrek Koszuliński %!s(int64=9) %!d(string=hai) anos
pai
achega
4743be63de

+ 34 - 33
packages/ckeditor5-engine/src/treeview/converter.js → packages/ckeditor5-engine/src/treeview/domconverter.js

@@ -9,20 +9,20 @@ import ViewText from './text.js';
 import ViewElement from './element.js';
 
 /**
- * Converter is a set of tools to do transformations between DOM nodes and view nodes. It also handles
- * {@link core.treeView.Converter#bindElements binding} these nodes.
+ * DomConverter is a set of tools to do transformations between DOM nodes and view nodes. It also handles
+ * {@link core.treeView.DomConverter#bindElements binding} these nodes.
  *
- * Converter does not check which nodes should be rendered (use {@link core.treeView.Renderer}), does not keep a state of
- * a tree nor keeps synchronization between tree view and DOM tree (use {@link @core.treeView.TreeView}).
+ * DomConverter does not check which nodes should be rendered (use {@link core.treeView.Renderer}), does not keep a
+ * state of a tree nor keeps synchronization between tree view and DOM tree (use {@link @core.treeView.TreeView}).
  *
- * Converter keeps DOM elements to View element bindings, so when the converter will be destroyed, the binding will be
- * lost. Two converters will keep separate binding maps, so one tree view can be bound with two DOM trees.
+ * DomConverter keeps DOM elements to View element bindings, so when the converter will be destroyed, the binding will
+ * be lost. Two converters will keep separate binding maps, so one tree view can be bound with two DOM trees.
  *
  * @memberOf core.treeView
  */
-export default class Converter {
+export default class DomConverter {
 	/**
-	 * Creates converter.
+	 * Creates DOM converter.
 	 */
 	constructor() {
 		// Using WeakMap prevent memory leaks: when the converter will be destroyed all referenced between View and DOM
@@ -37,7 +37,7 @@ export default class Converter {
 		 * DOM to View mapping.
 		 *
 		 * @private
-		 * @member {WeakMap} core.treeView.Converter#_domToViewMapping
+		 * @member {WeakMap} core.treeView.DomConverter#_domToViewMapping
 		 */
 		this._domToViewMapping = new WeakMap();
 
@@ -45,14 +45,15 @@ export default class Converter {
 		 * View to DOM mapping.
 		 *
 		 * @private
-		 * @member {WeakMap} core.treeView.Converter#_viewToDomMapping
+		 * @member {WeakMap} core.treeView.DomConverter#_viewToDomMapping
 		 */
 		this._viewToDomMapping = new WeakMap();
 	}
 
 	/**
 	 * Binds DOM and View elements, so it will be possible to get corresponding elements using
-	 * {@link core.treeView.Converter#getCorrespondingViewElement} and {@link core.treeView.Converter#getCorespondingDOMElement}.
+	 * {@link core.treeView.DomConverter#getCorrespondingViewElement} and
+	 * {@link core.treeView.DomConverter#getCorespondingDOMElement}.
 	 *
 	 * @param {HTMLElement} domElement DOM element to bind.
 	 * @param {core.treeView.Element} viewElement View element to bind.
@@ -92,7 +93,7 @@ export default class Converter {
 	 * @param {document} domDocument Document which will be used to create DOM nodes.
 	 * @param {Object} [options] Conversion options.
 	 * @param {Boolean} [options.bind=false] Determines whether new elements will be bound.
-	 * @param {Boolean} [options.withChildren=true] If true node's children will be converter too.
+	 * @param {Boolean} [options.withChildren=true] If true node's children will be converted too.
 	 * @returns {Node} Converted node.
 	 */
 	viewToDom( viewNode, domDocument, options ) {
@@ -134,7 +135,7 @@ export default class Converter {
 	 * @param {Node} domNode DOM node to transform.
 	 * @param {Object} [options] Conversion options.
 	 * @param {Boolean} [options.bind=false] Determines whether new elements will be bound.
-	 * @param {Boolean} [options.withChildren=true] It true node's children will be converter too.
+	 * @param {Boolean} [options.withChildren=true] It true node's children will be converted too.
 	 * @returns {core.treeView.Node} Converted node.
 	 */
 	domToView( domNode, options ) {
@@ -174,8 +175,8 @@ export default class Converter {
 	}
 
 	/**
-	 * Gets corresponding view node. This function use {@link core.treeView.Converter#getCorrespondingViewElement} for elements and
-	 * {@link getCorrespondingViewText} for text nodes.
+	 * Gets corresponding view node. This function use {@link core.treeView.DomConverter#getCorrespondingViewElement}
+	 * for elements and {@link getCorrespondingViewText} for text nodes.
 	 *
 	 * @param {Node} domNode DOM node.
 	 * @returns {core.treeView.Node|null} Corresponding node.
@@ -189,8 +190,8 @@ export default class Converter {
 	}
 
 	/**
-	 * Gets corresponding view element. Returns element if an view element was {@link core.treeView.Converter#bindElements bound} to the given
-	 * DOM element or null otherwise.
+	 * Gets corresponding view element. Returns element if an view element was
+	 * {@link core.treeView.DomConverter#bindElements bound} to the given DOM element or null otherwise.
 	 *
 	 * @param {HTMLElement} domElement DOM element.
 	 * @returns {core.treeView.Element|null} Corresponding element or null if none element was bound.
@@ -200,14 +201,14 @@ export default class Converter {
 	}
 
 	/**
-	 * Gets corresponding text node. Text nodes are not {@link core.treeView.Converter#bindElements bound}, corresponding text node is
-	 * returned based on the sibling or parent.
+	 * Gets corresponding text node. Text nodes are not {@link core.treeView.DomConverter#bindElements bound},
+	 * corresponding text node is returned based on the sibling or parent.
 	 *
-	 * If the directly previous sibling is a {@link core.treeView.Converter#bindElements bound} element, it is used to find the corresponding
-	 * text node.
+	 * If the directly previous sibling is a {@link core.treeView.DomConverter#bindElements bound} element, it is used
+	 * to find the corresponding text node.
 	 *
-	 * If this is a first child in the parent and the parent is a {@link core.treeView.Converter#bindElements bound} element, it is used to
-	 * find the corresponding text node.
+	 * If this is a first child in the parent and the parent is a {@link core.treeView.DomConverter#bindElements bound}
+	 * element, it is used to find the corresponding text node.
 	 *
 	 * Otherwise `null` is returned.
 	 *
@@ -244,8 +245,8 @@ export default class Converter {
 	}
 
 	/**
-	 * Gets corresponding DOM node. This function uses {@link core.treeView.Converter#getCorrespondingDomElement} for elements and
-	 * {@link core.treeView.Converter#getCorrespondingDomText} for text nodes.
+	 * Gets corresponding DOM node. This function uses {@link core.treeView.DomConverter#getCorrespondingDomElement} for
+	 * elements and {@link core.treeView.DomConverter#getCorrespondingDomText} for text nodes.
 	 *
 	 * @param {core.treeView.Node} viewNode View node.
 	 * @returns {Node|null} Corresponding DOM node.
@@ -259,8 +260,8 @@ export default class Converter {
 	}
 
 	/**
-	 * Gets corresponding DOM element. Returns element if an DOM element was {@link core.treeView.Converter#bindElements bound} to the given
-	 * view element or null otherwise.
+	 * Gets corresponding DOM element. Returns element if an DOM element was
+	 * {@link core.treeView.DomConverter#bindElements bound} to the given view element or null otherwise.
 	 *
 	 * @param {core.treeView.Element} viewElement View element.
 	 * @returns {HTMLElement|null} Corresponding element or null if none element was bound.
@@ -270,14 +271,14 @@ export default class Converter {
 	}
 
 	/**
-	 * Gets corresponding text node. Text nodes are not {@link core.treeView.Converter#bindElements bound}, corresponding text node is
-	 * returned based on the sibling or parent.
+	 * Gets corresponding text node. Text nodes are not {@link core.treeView.DomConverter#bindElements bound},
+	 * corresponding text node is returned based on the sibling or parent.
 	 *
-	 * If the directly previous sibling is a {@link core.treeView.Converter#bindElements bound} element, it is used to find the corresponding
-	 * text node.
+	 * If the directly previous sibling is a {@link core.treeView.DomConverter#bindElements bound} element, it is used
+	 * to find the corresponding text node.
 	 *
-	 * If this is a first child in the parent and the parent is a {@link core.treeView.Converter#bindElements bound} element, it is used to
-	 * find the corresponding text node.
+	 * If this is a first child in the parent and the parent is a {@link core.treeView.DomConverter#bindElements bound}
+	 * element, it is used to find the corresponding text node.
 	 *
 	 * Otherwise null is returned.
 	 *

+ 7 - 7
packages/ckeditor5-engine/src/treeview/observer/mutationobserver.js

@@ -62,11 +62,11 @@ export default class MutationObserver extends Observer {
 		this.domRoot = treeView.domRoot;
 
 		/**
-		 * Reference to the {@link core.treeView.TreeView#converter}.
+		 * Reference to the {@link core.treeView.TreeView#domConverter}.
 		 *
-		 * @member {core.treeView.Converter} core.treeView.observer.MutationObserver#converter
+		 * @member {core.treeView.DomConverter} core.treeView.observer.MutationObserver#domConverter
 		 */
-		this.converter = treeView.converter;
+		this.domConverter = treeView.domConverter;
 
 		/**
 		 * Reference to the {@link core.treeView.TreeView#renderer}.
@@ -114,7 +114,7 @@ export default class MutationObserver extends Observer {
 		// element with changed structure anyway.
 		for ( let mutation of domMutations ) {
 			if ( mutation.type === 'childList' ) {
-				const element = this.converter.getCorrespondingViewElement( mutation.target );
+				const element = this.domConverter.getCorrespondingViewElement( mutation.target );
 
 				if ( element ) {
 					mutatedElements.add( element );
@@ -125,7 +125,7 @@ export default class MutationObserver extends Observer {
 		// Handle `characterData` mutations later, when we have the full list of nodes which changed structure.
 		for ( let mutation of domMutations ) {
 			if ( mutation.type === 'characterData' ) {
-				const text = this.converter.getCorrespondingViewText( mutation.target );
+				const text = this.domConverter.getCorrespondingViewText( mutation.target );
 
 				if ( text && !mutatedElements.has( text.parent ) ) {
 					// Use text as a key, for deduplication. If there will be another mutation on the same text element
@@ -153,14 +153,14 @@ export default class MutationObserver extends Observer {
 		}
 
 		for ( let viewElement of mutatedElements ) {
-			const domElement = this.converter.getCorrespondingDomElement( viewElement );
+			const domElement = this.domConverter.getCorrespondingDomElement( viewElement );
 			const domChildren = domElement.childNodes;
 			const viewChildren = viewElement.getChildren();
 			const newViewChildren = [];
 
 			// We want to have a list of View elements, not DOM elements.
 			for ( let i = 0; i < domChildren.length; i++ ) {
-				newViewChildren.push( this.converter.domToView( domChildren[ i ] ) );
+				newViewChildren.push( this.domConverter.domToView( domChildren[ i ] ) );
 			}
 
 			this.renderer.markToSync( 'CHILDREN', viewElement );

+ 16 - 16
packages/ckeditor5-engine/src/treeview/renderer.js

@@ -12,7 +12,7 @@ import CKEditorError from '../ckeditorerror.js';
  * Renderer updates DOM tree, to make it a reflection of the view tree. Changed nodes need to be
  * {@link core.treeView.Renderer#markToSync marked} to be rendered. Then, on {@link core.treeView.Renderer#render render}, renderer
  * ensure they need to be refreshed and creates DOM nodes from view nodes,
- * {@link core.treeView.Converter#bindElements bind} them and insert into DOM tree. Renderer use {@link core.treeView.Converter}
+ * {@link core.treeView.DomConverter#bindElements bind} them and insert into DOM tree. Renderer use {@link core.treeView.DomConverter}
  * to transform and bind nodes.
  *
  * @memberOf core.treeView
@@ -21,16 +21,16 @@ export default class Renderer {
 	/**
 	 * Creates a renderer instance.
 	 *
-	 * @param {core.treeView.Converter} converter Converter instance.
+	 * @param {core.treeView.DomConverter} domConverter Converter instance.
 	 */
-	constructor( converter ) {
+	constructor( domConverter ) {
 		/**
 		 * Converter instance.
 		 *
 		 * @readonly
-		 * @member {core.treeView.Converter} core.treeView.Renderer#converter
+		 * @member {core.treeView.DomConverter} core.treeView.Renderer#domConverter
 		 */
-		this.converter = converter;
+		this.domConverter = domConverter;
 
 		/**
 		 * Set of nodes which attributes changed and may need to be rendered.
@@ -71,13 +71,13 @@ export default class Renderer {
 	 */
 	markToSync( type, node ) {
 		if ( type === 'TEXT' ) {
-			if ( this.converter.getCorrespondingDom( node.parent ) ) {
+			if ( this.domConverter.getCorrespondingDom( node.parent ) ) {
 				this.markedTexts.add( node );
 			}
 		} else {
 			// If the node has no DOM element it is not rendered yet,
 			// its children/attributes do not need to be marked to be sync.
-			if ( !this.converter.getCorrespondingDom( node ) ) {
+			if ( !this.domConverter.getCorrespondingDom( node ) ) {
 				return;
 			}
 
@@ -108,17 +108,17 @@ export default class Renderer {
 	 *
 	 * For text nodes it update the text string if it is different. Note that if parent element is marked as an element
 	 * which changed child list, text node update will not be done, because it may not be possible do find a
-	 * {@link core.treeView.Converter#getCorrespondingDomText corresponding DOM text}. The change will be handled in the
+	 * {@link core.treeView.DomConverter#getCorrespondingDomText corresponding DOM text}. The change will be handled in the
 	 * parent element.
 	 *
-	 * For nodes which changed child list it calculates a {@link diff} using {@link core.treeView.Converter#compareNodes}
+	 * For nodes which changed child list it calculates a {@link diff} using {@link core.treeView.DomConverter#compareNodes}
 	 * and add or removed nodes which changed.
 	 */
 	render() {
-		const converter = this.converter;
+		const domConverter = this.domConverter;
 
 		for ( let node of this.markedTexts ) {
-			if ( !this.markedChildren.has( node.parent ) && converter.getCorrespondingDom( node.parent ) ) {
+			if ( !this.markedChildren.has( node.parent ) && domConverter.getCorrespondingDom( node.parent ) ) {
 				updateText( node );
 			}
 		}
@@ -136,7 +136,7 @@ export default class Renderer {
 		this.markedChildren.clear();
 
 		function updateText( viewText ) {
-			const domText = converter.getCorrespondingDom( viewText );
+			const domText = domConverter.getCorrespondingDom( viewText );
 
 			if ( domText.data != viewText.data ) {
 				domText.data = viewText.data;
@@ -144,7 +144,7 @@ export default class Renderer {
 		}
 
 		function updateAttrs( viewElement ) {
-			const domElement = converter.getCorrespondingDom( viewElement );
+			const domElement = domConverter.getCorrespondingDom( viewElement );
 			const domAttrKeys = Array.from( domElement.attributes ).map( attr => attr.name );
 			const viewAttrKeys = viewElement.getAttributeKeys();
 
@@ -162,19 +162,19 @@ export default class Renderer {
 		}
 
 		function updateChildren( viewElement ) {
-			const domElement = converter.getCorrespondingDom( viewElement );
+			const domElement = domConverter.getCorrespondingDom( viewElement );
 			const domChildren = domElement.childNodes;
 			const viewChildren = Array.from( viewElement.getChildren() );
 			const domDocument = domElement.ownerDocument;
 
 			const actions = diff( domChildren, viewChildren,
-				( domNode, viewNode ) => converter.compareNodes( domNode, viewNode ) );
+				( domNode, viewNode ) => domConverter.compareNodes( domNode, viewNode ) );
 
 			let i = 0;
 
 			for ( let action of actions ) {
 				if ( action === 'INSERT' ) {
-					let domChildToInsert = converter.viewToDom( viewChildren[ i ], domDocument, { bind: true } );
+					let domChildToInsert = domConverter.viewToDom( viewChildren[ i ], domDocument, { bind: true } );
 					domElement.insertBefore( domChildToInsert, domChildren[ i ] || null );
 					i++;
 				} else if ( action === 'DELETE' ) {

+ 14 - 13
packages/ckeditor5-engine/src/treeview/treeview.js

@@ -7,16 +7,17 @@
 
 import EmitterMixin from '../emittermixin.js';
 import Renderer from './renderer.js';
-import Converter from './converter.js';
+import DomConverter from './domconverter.js';
 
 import utils from '../utils.js';
 
 /**
- * TreeView class combines the actual tree of view elements, tree of DOM elements, {@link core.treeView.Converter converter},
- * {@link core.treeView.Renderer renderer} and all {@link core.treeView.Observer observers}. It creates an abstract layer over the
- * content editable area.
+ * TreeView class combines the actual tree of view elements, tree of DOM elements,
+ * {@link core.treeView.DomConverter DOM Converter}, {@link core.treeView.Renderer renderer} and all
+ * {@link core.treeView.Observer observers}. It creates an abstract layer over the content editable area.
  *
- * If you want to only transform the tree of view elements to the DOM elements you can use the {@link core.treeView.Converter Converter}.
+ * If you want to only transform the tree of view elements to the DOM elements you can use the
+ * {@link core.treeView.DomConverter DomConverter}.
  *
  * @memberOf core.treeView
  * @mixes core.EmitterMixin
@@ -27,8 +28,8 @@ export default class TreeView {
 	 *
 	 * The constructor copies the element name and attributes to create the
 	 * root of the view, but does not copy its children. This means that the while rendering, the whole content of this
-	 * root element will be removed when you call {@link core.treeView.TreeView#render render} but the root name and attributes will
-	 * be preserved.
+	 * root element will be removed when you call {@link core.treeView.TreeView#render render} but the root name and
+	 * attributes will be preserved.
 	 *
 	 * @param {HTMLElement} domRoot DOM element in which the tree view should do change.
 	 */
@@ -48,19 +49,19 @@ export default class TreeView {
 		this.observers = new Set();
 
 		/**
-		 * Instance of the {@link core.treeView.Converter converter} use by {@link core.treeView.TreeView#renderer renderer} and
-		 * {@link core.treeView.TreeView#observers observers}.
+		 * Instance of the {@link core.treeView.DomConverter domConverter} use by
+		 * {@link core.treeView.TreeView#renderer renderer} and {@link core.treeView.TreeView#observers observers}.
 		 *
-		 * @member {core.treeView.Converter} core.treeView.TreeView#converter
+		 * @member {core.treeView.DomConverter} core.treeView.TreeView#domConverter
 		 */
-		this.converter = new Converter();
+		this.domConverter = new DomConverter();
 
 		/**
 		 * Root of the view tree.
 		 *
 		 * @member {core.treeView.Element} core.treeView.TreeView#viewRoot
 		 */
-		this.viewRoot = this.converter.domToView( domRoot, { bind: true, withChildren: false } );
+		this.viewRoot = this.domConverter.domToView( domRoot, { bind: true, withChildren: false } );
 		this.viewRoot.setTreeView( this );
 
 		/**
@@ -68,7 +69,7 @@ export default class TreeView {
 		 *
 		 * @member {core.treeView.Renderer} core.treeView.TreeView#renderer
 		 */
-		this.renderer = new Renderer( this.converter );
+		this.renderer = new Renderer( this.domConverter );
 		this.renderer.markToSync( 'CHILDREN', this.viewRoot );
 
 		// Mark changed nodes in the renderer.

+ 3 - 3
packages/ckeditor5-engine/tests/treeview/converter.js → packages/ckeditor5-engine/tests/treeview/domconverter.js

@@ -10,15 +10,15 @@
 import coreTestUtils from '/tests/core/_utils/utils.js';
 import ViewElement from '/ckeditor5/core/treeview/element.js';
 import ViewText from '/ckeditor5/core/treeview/text.js';
-import Converter from '/ckeditor5/core/treeview/converter.js';
+import DomConverter from '/ckeditor5/core/treeview/domconverter.js';
 
 const getIteratorCount = coreTestUtils.getIteratorCount;
 
-describe( 'converter', () => {
+describe( 'DomConverter', () => {
 	let converter;
 
 	before( () => {
-		converter = new Converter();
+		converter = new DomConverter();
 	} );
 
 	describe( 'bindElements', () => {

+ 7 - 7
packages/ckeditor5-engine/tests/treeview/renderer.js

@@ -10,15 +10,15 @@
 import Renderer from '/ckeditor5/core/treeview/renderer.js';
 import ViewElement from '/ckeditor5/core/treeview/element.js';
 import ViewText from '/ckeditor5/core/treeview/text.js';
-import Converter from '/ckeditor5/core/treeview/converter.js';
+import DomConverter from '/ckeditor5/core/treeview/domconverter.js';
 import CKEditorError from '/ckeditor5/core/ckeditorerror.js';
 
 describe( 'Renderer', () => {
-	let converter, renderer;
+	let domConverter, renderer;
 
 	before( () => {
-		converter = new Converter();
-		renderer = new Renderer( converter );
+		domConverter = new DomConverter();
+		renderer = new Renderer( domConverter );
 	} );
 
 	describe( 'markToSync', () => {
@@ -28,7 +28,7 @@ describe( 'Renderer', () => {
 			viewNode = new ViewElement( 'p' );
 
 			const domNode = document.createElement( 'p' );
-			converter.bindElements( domNode, viewNode );
+			domConverter.bindElements( domNode, viewNode );
 			viewNode.appendChildren( new ViewText( 'foo' ) );
 
 			renderer.markedTexts.clear();
@@ -100,7 +100,7 @@ describe( 'Renderer', () => {
 			viewNode = new ViewElement( 'p' );
 			domNode = document.createElement( 'p' );
 
-			converter.bindElements( domNode, viewNode );
+			domConverter.bindElements( domNode, viewNode );
 
 			renderer.markedTexts.clear();
 			renderer.markedAttributes.clear();
@@ -240,7 +240,7 @@ describe( 'Renderer', () => {
 			const domImg = document.createElement( 'img' );
 			domNode.appendChild( domImg );
 
-			converter.bindElements( domImg, viewImg );
+			domConverter.bindElements( domImg, viewImg );
 
 			renderer.markToSync( 'CHILDREN', viewNode );
 			renderer.render();

+ 3 - 3
packages/ckeditor5-engine/tests/treeview/treeview.js

@@ -10,7 +10,7 @@
 import TreeView from '/ckeditor5/core/treeview/treeview.js';
 import Observer from '/ckeditor5/core/treeview/observer/observer.js';
 import Renderer from '/ckeditor5/core/treeview/renderer.js';
-import Converter from '/ckeditor5/core/treeview/converter.js';
+import DomConverter from '/ckeditor5/core/treeview/domconverter.js';
 
 describe( 'TreeView', () => {
 	describe( 'constructor', () => {
@@ -25,10 +25,10 @@ describe( 'TreeView', () => {
 			expect( treeView ).to.have.property( 'domRoot' ).that.equals( domDiv );
 			expect( treeView ).to.have.property( 'observers' ).that.is.instanceOf( Set );
 			expect( treeView ).to.have.property( 'renderer' ).that.is.instanceOf( Renderer );
-			expect( treeView ).to.have.property( 'converter' ).that.is.instanceOf( Converter );
+			expect( treeView ).to.have.property( 'domConverter' ).that.is.instanceOf( DomConverter );
 			expect( treeView ).to.have.property( 'viewRoot' );
 
-			expect( treeView.converter.getCorrespondingDom( treeView.viewRoot ) ).to.equal( domDiv );
+			expect( treeView.domConverter.getCorrespondingDom( treeView.viewRoot ) ).to.equal( domDiv );
 			expect( treeView.viewRoot.name ).to.equal( 'div' );
 			expect( treeView.viewRoot.getAttribute( 'id' ) ).to.equal( 'editor' );
 			expect( treeView.renderer.markedChildren.has( treeView.viewRoot ) ).to.be.true;