Merge branch 'release/1.1.1'

Author: swayf

README.md

@@ -73,8 +73,9 @@ The path is used for recursive methods and is kept up to date by the plugin if t
 
 Signature:
 
-    getChildren([recursive], cb);
+    getChildren([args], [recursive], cb);
 
+args are additional filters if needed.
 if recursive is supplied and true, subchildren are returned
 
 Based on the above hierarchy:
@@ -116,7 +117,7 @@ args is an object you can defined with theses properties :
       example: minLevel:2
 
     recursive: boolean, default true
-      make the search recursive or only fetch childs for the specified level
+      make the search recursive or only fetch children for the specified level
       example: recursive:false
 
     allowEmptyChildren: boolean, default true
@@ -170,7 +171,7 @@ adam.getChildrenTree( function(err, users) {
 
 Signature:
 
-    getAncestors(cb);
+    getAncestors([args], cb);
 
 Based on the above hierarchy:
 

lib/tree.js

@@ -1,7 +1,9 @@
 var Schema = require('mongoose').Schema;
 
+
 module.exports = exports = tree;
 
+
 /**
  * @class tree
  * Tree Behavior for Mongoose
@@ -13,6 +15,7 @@ module.exports = exports = tree;
  * @param  {Object} options
  */
 function tree(schema, options) {
+
     var pathSeparator = options && options.pathSeparator || '#'
         , onDelete = options && options.onDelete || 'DELETE'; //'REPARENT'
 
@@ -36,6 +39,7 @@ function tree(schema, options) {
         }
     });
 
+
     /**
      * Pre-save middleware
      * Build or rebuild path when needed
@@ -53,6 +57,7 @@ function tree(schema, options) {
 
             var self = this;
             this.collection.findOne({ _id: this.parent }, function (err, doc) {
+
                 if (err) return next(err);
 
                 var previousPath = self.path;
@@ -61,33 +66,40 @@ function tree(schema, options) {
                 if (isParentChange) {
                     // When the parent is changed we must rewrite all children paths as well
                     self.collection.find({ path: { '$regex': '^' + previousPath + pathSeparator } }, function (err, cursor) {
+
                         if (err) return next(err);
 
                         var stream = cursor.stream();
                         stream.on('data', function (doc) {
                             var newPath = self.path + doc.path.substr(previousPath.length);
                             self.collection.update({ _id: doc._id }, { $set: { path: newPath } }, function (err) {
+
                                 if (err) return next(err);
                             });
                         });
+
                         stream.on('close', next);
                         stream.on('error', next);
                     });
-                } else {
+                }
+                else {
                     next();
                 }
             });
-        } else {
+        }
+        else {
             next();
         }
     });
 
+
     /**
      * Pre-remove middleware
      *
      * @param  {Function} next
      */
     schema.pre('remove', function preRemove(next) {
+
         if (!this.path)
             return next();
 
@@ -101,21 +113,27 @@ function tree(schema, options) {
 
             // Update parent property from children
             this.collection.find({ parent: previousParent }, function (err, cursor) {
+
                 if (err) return next(err);
                 var stream = cursor.stream();
                 stream.on('data', function streamOnData(doc) {
+
                     self.collection.update({ _id: doc._id }, { $set: { parent: newParent } }, function (err) {
+
                         if (err) return next(err);
                     });
                 });
                 stream.on('close', function streamOnClose() {
+
                     // Cascade update Path
                     self.collection.find({ path: { $regex: previousParent + pathSeparator} }, function (err, cursor) {
 
                         var subStream = cursor.stream();
                         subStream.on('data', function subStreamOnData(doc) {
+
                             var newPath = doc.path.replace(previousParent + pathSeparator, '');
                             self.collection.update({ _id: doc._id }, { $set: { path: newPath } }, function (err) {
+
                                 if (err) return next(err);
                             });
                         });
@@ -129,47 +147,81 @@ function tree(schema, options) {
         }
     });
 
+
     /**
      * @method getChildren
      *
-     * @param  {[type]}   recursive
-     * @param  {Function} next
+     * @param  {Object}    args
+     * @param  {Boolean}   recursive
+     * @param  {Function}  next
      * @return {Model}
      */
-    schema.methods.getChildren = function getChildren(recursive, next) {
-        if (typeof(recursive) === "function") {
-            next = recursive;
+    schema.methods.getChildren = function getChildren(args, recursive, next) {
+
+        // normalize the arguments
+        if ("function" === typeof args) {
+            next = args;
             recursive = false;
+            args = {};
         }
-        var filter = recursive ? { path: { $regex: '^' + this.path + pathSeparator } } : { parent: this._id };
-        return this.model(this.constructor.modelName).find(filter, next);
+        else if ("function" === typeof recursive) {
+            next = recursive;
+            if (args instanceof Object) {
+                recursive = false;
+            }
+            else {
+                recursive = args;
+                args = {};
+            }
+        }
+
+        if (recursive) {
+            args['path'] = {$regex: '^' + this.path + pathSeparator}
+        }
+        else {
+            args['parent'] = this._id
+        }
+
+        return this.model(this.constructor.modelName).find(args, next);
     };
 
+
     /**
      * @method getParent
      *
      * @param  {Function} next
      * @return {Model}
      */
     schema.methods.getParent = function getParent(next) {
+
         return this.model(this.constructor.modelName).findOne({ _id: this.parent }, next);
     };
 
+
     /**
      * @method getAncestors
      *
+     * @param  {Object}   args
      * @param  {Function} next
      * @return {Model}
      */
-    schema.methods.getAncestors = function getAncestors(next) {
+    schema.methods.getAncestors = function getAncestors(args, next) {
+
+        if ("function" === typeof args) {
+            next = args;
+            args = {};
+        }
+
+        var ids = [];
+
         if (this.path) {
-            var ids = this.path.split(pathSeparator);
+            ids = this.path.split(pathSeparator);
             ids.pop();
-        } else {
-            var ids = [];
         }
-        var filter = { _id: { $in: ids } };
-        return this.model(this.constructor.modelName).find(filter, next);
+
+        args['_id'] = {$in: ids};
+
+        return this.model(this.constructor.modelName).find(args, next);
     };
 
 
@@ -187,23 +239,23 @@ function tree(schema, options) {
      * @param  {Function} next
      * @return {Model}
      */
-    schema.statics.getChildrenTree = function getChildrenTree(root, args, cb) {
+    schema.statics.getChildrenTree = function getChildrenTree(root, args, next) {
 
         if ("function" === typeof(root))
         {
-            cb = root;
+            next = root;
             root = null;
             args = {};
         }
         else if ("function" === typeof(args)) {
-            cb = args
+            next = args;
 
             if ("model" in root) {
                 args = {};
             }
             else
             {
-                args = root
+                args = root;
                 root = null
             }
         }
@@ -215,7 +267,7 @@ function tree(schema, options) {
         var recursive = args.recursive != undefined ? args.recursive : true;
         var allowEmptyChildren = args.allowEmptyChildren != undefined ? args.allowEmptyChildren : true;
 
-        if (!cb)
+        if (!next)
             throw new Error('no callback defined when calling getChildrenTree');
 
         // filters: Add recursive path filter or not
@@ -250,18 +302,23 @@ function tree(schema, options) {
         }
 
         // options:sort , path sort is mandatory
-        if (!options.sort) options.sort = {};
+        if (!options.sort) {
+            options.sort = {};
+        }
         options.sort.path = 1;
         options.lean = true;
 
         return this.find(filters, fields, options, function (err, results) {
+
             if (err) throw err;
 
             var getLevel = function (path) {
+
                 return path ? path.split(pathSeparator).length : 0;
             };
 
             var createChildren = function (arr, node, level) {
+
                 if (level == minLevel) {
                     if (allowEmptyChildren)
                         node.children = [];
@@ -291,19 +348,23 @@ function tree(schema, options) {
                 createChildren(finalResults, results[r], level);
             }
 
-            cb(err, finalResults);
+            next(err, finalResults);
 
         });
     };
 
+
     schema.methods.getChildrenTree = function(args, cb) {
+
         this.constructor.getChildrenTree(this, args, cb)
     };
 
+
     /**
      * @property {Number} level <virtual>
      */
     schema.virtual('level').get(function virtualPropLevel() {
+
         return this.path ? this.path.split(pathSeparator).length : 0;
     });
 }

package.json

@@ -5,6 +5,7 @@
         "Franck Tab <franck.tab@gmail.com>",
         "Tomáš Holas <tomas.holas@gmail.com>",
         "Oleg Butovich <obutovich@gmail.com>",
+        "Jake Dempsey <angelo0000@gmail.com>",
         "Alban Escalier (DaWyz)"
     ],
     "name": "mongoose-path-tree",
@@ -15,15 +16,15 @@
         "url": "git://github.com/swayf/mongoose-path-tree.git"
     },
     "main": "index.js",
-    "version": "1.0.2",
+    "version": "1.1.1",
     "engine": "node >= 0.4.0",
     "dependencies": {
         "mongoose": "3.x.x"
     },
     "devDependencies": {
         "async": "0.x.x",
         "should": "1.x.x",
-        "underscore": "1.x.x",
+        "lodash": "2.x.x",
         "mocha": "1.x.x"
     },
     "directories": {

test/tree.js

@@ -3,7 +3,7 @@ var assert = require('assert'),
     tree = require('../lib/tree'),
     async = require('async'),
     should = require('should'),
-    _ = require('underscore');
+    _ = require('lodash');
 
 var Schema = mongoose.Schema;
 
@@ -138,6 +138,19 @@ describe('tree tests', function () {
     });
 
     describe('get children', function () {
+        it('should return immediate children with filters', function (done) {
+            User.findOne({ 'name': 'Adam' }, function (err, adam) {
+                should.not.exist(err);
+
+                adam.getChildren({ name: 'Bob' }, function (err, users) {
+                    should.not.exist(err);
+
+                    users.length.should.equal(1);
+                    _.pluck(users, 'name').should.include('Bob');
+                    done();
+                });
+            });
+        });
         it('should return immediate children', function (done) {
             User.findOne({ 'name': 'Adam' }, function (err, adam) {
                 should.not.exist(err);