Issue 4 of cosmoz-treenode-navigator

.gitignore

@@ -1,3 +1,4 @@
 bower_components/
 node_modules/
 debug.log
+.DS_Store

cosmoz-default-tree.html

@@ -1,10 +1,21 @@
 <link rel="import" href="cosmoz-tree.html">
+
+<!--
+Navigator through object with treelike datastructure and default settings.
+
+@demo demo/index.html
+-->
 <script>
 	'use strict';
 
+	Polymer({ is: 'cosmoz-default-tree' });
+
 	window.Cosmoz = window.Cosmoz || {};
 
 	function _objectValues(obj) {
+		if (!obj) {
+			return;
+		}
 		return Object.keys(obj).map(function (key) {
 			return obj[key];
 		});
@@ -23,134 +34,192 @@
 
 	Cosmoz.DefaultTree.prototype = Object.create(Cosmoz.Tree.prototype);
 
-	Cosmoz.DefaultTree.prototype.getNodeByProperty = function (propertyName, propertyValue) {
+	/**
+	 * Returns the first node found.
+	 * @return {object} or null if there was an empty response.
+	 * @param {string} propertyName (The name of the property the match should be based on. e.g. "name")
+	 * @param {string} propertyValue (The value of the property the match should be based on. e.g. "Peter")
+	 * @param {boolean} exact (If the search should be executed exact or flaw. true wouldn't match "Pet")
+	 * @param {object} nodeObj (The object the search should be based on.) or on default this._treeData
+	 */
+	Cosmoz.DefaultTree.prototype.getNodeByProperty = function (propertyName, propertyValue, exact, nodeObj) {
 		if (propertyName === undefined || propertyValue === undefined) {
 			return;
 		}
+		// Defaults
+		exact = exact !== undefined ? exact : true;
 
 		if (propertyName === 'pathLocator') {
-			return this._getNodeByPathLocator(propertyValue);
+			return this.getNodeByPathLocator(propertyValue, nodeObj);
 		}
 
-		return this._searchAllRoots(propertyName, propertyValue);
+		var results = this.searchNodes(propertyName, propertyValue, exact, nodeObj);
+		return results && results.length > 0 ? results[0] : null;
 	};
 
-	Cosmoz.DefaultTree.prototype.getPath = function (node) {
-		if (node === undefined) {
-			return;
-		}
-		return this._getPathByPathLocator(node.pathLocator);
+	/**
+	 * Searches a (multi root) node and matches nodes based on a property and a value.
+	 * @return {array}
+	 * @param {string} propertyName (The name of the property the match should be based on. e.g. "name")
+	 * @param {string} propertyValue (The value of the property the match should be based on. e.g. "Peter")
+	 * @param {boolean} exact (If the search should be executed exact or flaw. true wouldn't match "Pet")
+	 * @param {object} nodeObj (The object the search should be based on.) or on default this._treeData
+	 * @param {string} childProperty (The string which describes the child property of a node.) Default: "children"
+	*/
+	Cosmoz.DefaultTree.prototype.searchNodes = function (propertyName, propertyValue, exact, nodeObj, childProperty) {
+		var results = [];
+
+		// Defaults
+		exact = exact !== undefined ? exact : true;
+		var nodes = nodeObj ? _objectValues(nodeObj) : this._roots;
+
+		nodes.forEach(function (node) {
+			results = results.concat(this.search(node, propertyName, propertyValue, exact, childProperty));
+		}, this);
+
+		return results;
 	};
 
-	Cosmoz.DefaultTree.prototype.getPathByProperty = function (propertyName, propertyValue) {
-		if (propertyName === undefined || propertyValue === undefined) {
-			return;
+	/**
+	 * Returns the node of a given path.
+	 * @return {object}
+	 * @param {string} pathLocator (The string which describes the path. e.g. "1.2.9")
+	 * @param {object} nodeObj (The object the search should be based on.) Default: this._treeData
+	 * @param {string} separatorSign (The string which separates the path. e.g ".") Default: "."
+	 * @param {string} childProperty (The string which describes the child property of a node.) Default: "children"
+	*/
+	Cosmoz.DefaultTree.prototype.getNodeByPathLocator = function (pathLocator, nodeObj, separatorSign, childProperty) {
+		if (!pathLocator) {
+			return this._treeData;
 		}
 
-		if (propertyName === 'pathLocator') {
-			return this._getPathByPathLocator(propertyValue);
-		}
+		// Defaults
+		nodeObj = nodeObj ? nodeObj : this._treeData;
+		separatorSign = separatorSign ? separatorSign : '.';
+		childProperty = childProperty ? childProperty : 'children';
 
-		var node = this._searchAllRoots(propertyName, propertyValue);
-		if (node !== undefined) {
-			return this._getPathByPathLocator(node.pathLocator);
-		}
+		var	pathNodes = this.getPathNodes(pathLocator, nodeObj, separatorSign, childProperty),
+			lastNodeOnPath = pathNodes.pop();
+		return lastNodeOnPath !== undefined ? lastNodeOnPath : null;
 	};
 
-	Cosmoz.DefaultTree.prototype.getChildren = function (node) {
-		if (node === undefined) {
-			return;
+	/**
+	 * Returns the nodes on a given path.
+	 * @return {array} or null if there was an empty response.
+	 * @param {string} pathLocator (The string which describes the path. e.g. "1.2.9")
+	 * @param {object} nodeObj (The object the search should be based on.) Default: this._treeData
+	 * @param {string} separatorSign (The string which separates the path. e.g ".") Default: "."
+	 * @param {string} childProperty (The string which describes the child property of a node.) Default: "children"
+	*/
+	Cosmoz.DefaultTree.prototype.getPathNodes = function (pathLocator, nodeObj, separatorSign, childProperty) {
+		if (!pathLocator) {
+			return this._roots;
 		}
-		return _objectValues(node.children);
-	};
 
-	Cosmoz.DefaultTree.prototype.getProperty = function (node, propertyName) {
-		if (node === undefined || propertyName === undefined) {
-			return;
-		}
+		// Defaults
+		separatorSign = separatorSign ? separatorSign : '.';
+		childProperty = childProperty ? childProperty : 'children';
+
+		var path = pathLocator.split(separatorSign),
+			pathSegment = nodeObj ? nodeObj : this._treeData,
+			pathIsInvalid,
+			nodes;
+
+		// Get the nodes on the path.
+		nodes = path.map(function (nodeKey) {
+			var node = pathSegment[nodeKey],
+				children = node[childProperty];
+			if (node && children !== undefined && Object.keys(children).length > 0) {
+				pathSegment = children;
+			}
+			return node;
+		}, this);
 
-		return node[propertyName];
-	};
+		// Check if all nodes on the path are valid.
+		pathIsInvalid = nodes.some(function (n) {
+			if (n === undefined) {
+				return true;
+			}
+		});
 
-	Cosmoz.DefaultTree.prototype._searchAllRoots = function (propertyName, propertyValue) {
-		var i,
-			node;
+		return pathIsInvalid ? null : nodes;
+	},
 
-		for (i = 0; i < this._roots.length; i+=1) {
-			node = this.search(this._roots[i], propertyName, propertyValue);
-			if (node !== undefined) {
-				return node;
-			}
-		}
+	/**
+	 * Returns a string which describes the path of a node (found by its path locator).
+	 * @return {string} e.g. home/computer/desktop
+	 * @param {string} pathLocator (The string which describes the path. e.g. "1.2.9")
+	 * @param {string} pathProperty (The property of a node on which the path should be build on. e.g "location" if node = {"location": "home"})
+	 * @param {string} pathSeparator (The string the path should get separated with.) Default: "/"
+	 * @param {string} separatorSign (The string which separates the path. e.g ".") Default: "."
+	 * @param {string} childProperty (The string which describes the child property of a node.) Default: "children"
+	*/
+	Cosmoz.DefaultTree.prototype.getPathString = function (pathLocator, pathProperty, pathSeparator, separatorSign, childProperty) {
+		var pathNodes = this.getPathNodes(pathLocator, this._treeData);
+
+		// Defaults
+		pathSeparator = pathSeparator ? pathSeparator : '/';
+		separatorSign = separatorSign ? separatorSign : '.';
+		childProperty = childProperty ? childProperty : 'children';
+
+		return pathNodes.map(function (node) {
+			return node[pathProperty];
+		}).join(pathSeparator);
 	};
 
-	Cosmoz.DefaultTree.prototype._getNodeByPathLocator = function (pathLocator) {
-		var	node,
-			path,
-			i;
+	/**
+	 * Returns a string which describes the path of a node (found by a node's property and value).
+	 * @return {string} e.g. home/computer/desktop
+	 * @param {string} propertyName (The name of the property the match should be based on. e.g. "name")
+	 * @param {string} propertyValue (The value of the property the match should be based on. e.g. "Peter")
+	 * @param {string} pathProperty (The property of a node on which the path should be build on. e.g "location" if node = {"location": "home"})
+	 * @param {string} pathSeparator (The string the path should get separated with.) Default: "/"
+	 * @param {string} separatorSign (The string which separates the path. e.g ".") Default: "."
+	 * @param {string} childProperty (The string which describes the child property of a node.) Default: "children"
+	*/
+	Cosmoz.DefaultTree.prototype.getPathStringByProperty = function (propertyName, propertyValue, pathProperty, pathSeparator, separatorSign, childProperty) {
+		if (propertyName === undefined || propertyValue === undefined) {
+			return;
+		}
 
-		for (i = 0; i < this._roots.length; i+=1) {
-			node = this._roots[i];
-			if (node.pathLocator === pathLocator) {
-				return node;
-			}
+		// Defaults
+		pathProperty = pathProperty ? pathProperty : 'name';
+		separatorSign = separatorSign ? separatorSign : '.';
+		childProperty = childProperty ? childProperty : 'children';
 
-			if (pathLocator.indexOf(node.pathLocator + '.') === 0) {
-				path = pathLocator.slice(node.pathLocator.length + 1).split('.');
-				for (i = 0; i < path.length; i+=1) {
-					if (node.children) {
-						node = node.children[path[i]];
-					} else {
-						node = null;
-					}
-					if (node === undefined ||  node === null) {
-						break;
-					}
-				}
-
-				if (node !== undefined && node !== null) {
-					return node;
-				}
-			}
+		if (propertyName === 'pathLocator') {
+			return this.getPathString(propertyValue, pathProperty);
+		}
+
+		var node = this.getNodeByProperty(propertyName, propertyValue);
+
+		if (node) {
+			return this.getPathString(node.pathLocator || node.path, pathProperty);
 		}
 	};
 
-	Cosmoz.DefaultTree.prototype._getPathByPathLocator = function (pathLocator) {
-		var	node,
-			path,
-			subPath,
-			i;
+	/**
+	 * Returns an Object or an Array representing the children of a node.
+	 */
+	Cosmoz.DefaultTree.prototype.getChildren = function (node, childProperty) {
+		if (!node) {
+			return;
+		}
 
-		for (i = 0; i < this._roots.length; i+=1) {
-			node = this._roots[i];
-			path = [node];
+		// Defaults
+		childProperty = childProperty ? childProperty : 'children';
 
-			if (node.pathLocator === pathLocator) {
-				return path;
-			}
+		return _objectValues(node[childProperty]);
+	};
 
-			if (pathLocator.indexOf(node.pathLocator + '.') === 0) {
-				subPath = pathLocator.slice(node.pathLocator.length + 1).split('.');
-				for (i = 0; i < subPath.length; i+=1) {
-					if (node.children) {
-						node = node.children[subPath[i]];
-					} else {
-						node = null;
-					}
-					if (node === undefined ||  node === null) {
-						path = null;
-						break;
-					} else {
-						path.push(node);
-					}
-				}
-
-				if (path !== null) {
-					return path;
-				}
-			}
+	/**
+	 * Returns the property of a Node based on a given property name.
+	 */
+	Cosmoz.DefaultTree.prototype.getProperty = function (node, propertyName) {
+		if (!node || !propertyName) {
+			return;
 		}
+		return node[propertyName];
 	};
 
-
-</script>
+</script>