Added editorconfig & applied formatting

Author: martin-css

.editorconfig

@@ -0,0 +1,8 @@
+[*]
+indent_style = space
+indent_size = 4
+charset = utf-8
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 100

lib/id-validator.js

@@ -1,130 +1,137 @@
-var mongoose = require('mongoose');
-var traverse = require('traverse');
-var clone = require('clone');
-var Schema = mongoose.Schema;
+var mongoose = require('mongoose')
+var traverse = require('traverse')
+var clone = require('clone')
+var Schema = mongoose.Schema
 
-function IdValidator() {
-    this.enabled = true;
+function IdValidator () {
+    this.enabled = true
 }
 
 IdValidator.prototype.enable = function () {
-    this.enabled = true;
-};
+    this.enabled = true
+}
 
 IdValidator.prototype.disable = function () {
-    this.enabled = false;
-};
+    this.enabled = false
+}
 
 IdValidator.prototype.validate = function (schema, options) {
-    var self = this;
-    options = options || {};
-    var message = options.message || "{PATH} references a non existing ID";
-    var connection = options.connection || mongoose;
-    var allowDuplicates = options.allowDuplicates || false;
+    var self = this
+    options = options || {}
+    var message = options.message || '{PATH} references a non existing ID'
+    var connection = options.connection || mongoose
+    var allowDuplicates = options.allowDuplicates || false
 
-    var caller = (self instanceof IdValidator) ? self : IdValidator.prototype;
+    var caller = (self instanceof IdValidator) ? self : IdValidator.prototype
 
-    return caller.validateSchema(schema, message, connection, allowDuplicates);
-};
+    return caller.validateSchema(schema, message, connection, allowDuplicates)
+}
 
-IdValidator.prototype.validateSchema = function (schema, message, connection, allowDuplicates) {
-    var self = this;
-    var caller = (self instanceof IdValidator) ? self : IdValidator.prototype;
+IdValidator.prototype.validateSchema = function (
+    schema, message, connection, allowDuplicates) {
+    var self = this
+    var caller = (self instanceof IdValidator) ? self : IdValidator.prototype
     schema.eachPath(function (path, schemaType) {
 
         //Apply validation recursively to sub-schemas
         if (schemaType.schema) {
-            return caller.validateSchema(schemaType.schema, message, connection);
+            return caller.validateSchema(schemaType.schema, message,
+                connection)
         }
 
-        var validateFunction = null;
-        var refModelName = null;
-        var conditions = {};
+        var validateFunction = null
+        var refModelName = null
+        var conditions = {}
 
         if (schemaType.options && schemaType.options.ref) {
-            validateFunction = validateId;
-            refModelName = schemaType.options.ref;
+            validateFunction = validateId
+            refModelName = schemaType.options.ref
             if (schemaType.options.refConditions) {
-                conditions = schemaType.options.refConditions;
+                conditions = schemaType.options.refConditions
             }
-        } else if (schemaType.caster && schemaType.caster.instance && schemaType.caster.options && schemaType.caster.options.ref) {
-            validateFunction = validateIdArray;
-            refModelName = schemaType.caster.options.ref;
+        } else if (schemaType.caster && schemaType.caster.instance &&
+            schemaType.caster.options && schemaType.caster.options.ref) {
+            validateFunction = validateIdArray
+            refModelName = schemaType.caster.options.ref
             if (schemaType.caster.options.refConditions) {
-                conditions = schemaType.caster.options.refConditions;
+                conditions = schemaType.caster.options.refConditions
             }
         }
 
         if (validateFunction) {
             schema.path(path).validate({
                 validator: function (value, respond) {
-                    var conditionsCopy = conditions;
+                    var conditionsCopy = conditions
                     //A query may not implement an isModified function.
                     if (!!this.isModified && !this.isModified(path)) {
-                        return respond(true);
+                        return respond(true)
                     }
                     if (!(self instanceof IdValidator) || self.enabled) {
                         if (Object.keys(conditionsCopy).length > 0) {
-                            var instance = this;
+                            var instance = this
 
-                            conditionsCopy = clone(conditions);
+                            conditionsCopy = clone(conditions)
                             traverse(conditionsCopy).forEach(function (value) {
                                 if (typeof value === 'function') {
-                                    this.update(value.call(instance));
+                                    this.update(value.call(instance))
                                 }
-                            });
+                            })
                         }
 
-                        return validateFunction(this, connection, refModelName, value, conditionsCopy, respond, allowDuplicates);
+                        return validateFunction(this, connection, refModelName,
+                            value, conditionsCopy, respond, allowDuplicates)
                     }
-                    return respond(true);
+                    return respond(true)
                 },
                 isAsync: true,
                 message: message
-            });
+            })
         }
-    });
-};
+    })
+}
 
-function executeQuery(query, conditions, validateValue, respond) {
+function executeQuery (query, conditions, validateValue, respond) {
     for (var fieldName in conditions) {
-        query.where(fieldName, conditions[fieldName]);
+        query.where(fieldName, conditions[fieldName])
     }
     query.exec(function (err, count) {
         if (err) {
-            return respond(err);
+            return respond(err)
         }
-        respond(count === validateValue);
-    });
+        respond(count === validateValue)
+    })
 }
 
-function validateId(doc, connection, refModelName, value, conditions, respond) {
+function validateId (
+    doc, connection, refModelName, value, conditions, respond) {
     if (value == null) {
-        return respond(true);
+        return respond(true)
     }
-    var refModel = connection.model(refModelName);
-    var query = refModel.count({_id: value});
-    executeQuery(query, conditions, 1, respond);
+    var refModel = connection.model(refModelName)
+    var query = refModel.count({_id: value})
+    executeQuery(query, conditions, 1, respond)
 }
 
-function validateIdArray(doc, connection, refModelName, values, conditions, respond, allowDuplicates) {
+function validateIdArray (
+    doc, connection, refModelName, values, conditions, respond,
+    allowDuplicates) {
     if (values == null || values.length == 0) {
-        return respond(true);
+        return respond(true)
     }
 
-    var checkValues = values;
+    var checkValues = values
     if (allowDuplicates) {
         //Extract unique values only
         checkValues = values.filter(function (v, i) {
             return values.indexOf(v) === i
-        });
+        })
     }
 
-    var refModel = connection.model(refModelName);
-    var query = refModel.count().where('_id')['in'](checkValues);
+    var refModel = connection.model(refModelName)
+    var query = refModel.count().where('_id')['in'](checkValues)
 
-    executeQuery(query, conditions, checkValues.length, respond);
+    executeQuery(query, conditions, checkValues.length, respond)
 }
 
-module.exports = IdValidator.prototype.validate;
-module.exports.getConstructor = IdValidator;
+module.exports = IdValidator.prototype.validate
+module.exports.getConstructor = IdValidator