Merge pull request #22 from PlayNetwork/v0.2.14

Looking good!
PlayNetwork · Feb 22, 2016 · 5d9afb9 · 5d9afb9
2 parents 64c2ae4 + 5d6cc59
commit 5d9afb9
Show file tree

Hide file tree

Showing 7 changed files with 267 additions and 142 deletions.
diff --git a/.jshintrc b/.jshintrc
@@ -1,5 +1,6 @@
 {
 	"bitwise" : true,
+	"browser" : false,
 	"camelcase" : true,
 	"curly" : true,
 	"eqeqeq" : true,

diff --git a/.travis.yml b/.travis.yml
@@ -1,4 +1,6 @@
 language: node_js
 node_js:
-    - 0.10
     - 0.12
+    - 4.3
+after_success:
+  - gulp coveralls
diff --git a/gulpfile.js b/gulpfile.js
@@ -21,6 +21,7 @@ gulp.task('coveralls', function () {
 		.pipe(coveralls());
 });
 
+
 gulp.task('jshint', function () {
 	return gulp
 		.src(['lib/**/*.js', 'test/**/*.js'])

diff --git a/history.md b/history.md
@@ -1,3 +1,9 @@
+# v0.2.14 / 2016-02-22
+
+* Increasing code coverage of unit tests with minor refactors
+* Adding `gulp coveralls` task to end of Travis build
+* Adding support for `notEqual` mandatory and optional filters
+
 # v0.2.13 / 2015-11-11
 
 * Adding ability to specify filters as arrays via comma-delim strings

diff --git a/lib/filter.js b/lib/filter.js
@@ -16,125 +16,64 @@ module.exports = function(mongoose) {
 			optional = options.filters.optional || {},
 			self = this;
 
-		var applyWhere = function (spec, buildRegex) {
+		var applyGreaterThan = function (spec, clause) {
 			for (var key in spec) {
 				if (spec.hasOwnProperty(key)) {
-					var val = buildRegex(spec[key]);
-
-					self.where(key, val);
-				}
-			}
-		};
-
-		var applyWhereGreaterThan = function (spec) {
-			for (var key in spec) {
-				if (spec.hasOwnProperty(key)) {
-					self.where(key).gt(spec[key]);
+					clause(key).gt(spec[key]);
 				}
 			}
 		};
 
-		var applyWhereGreaterThanEqual = function (spec) {
+		var applyGreaterThanEqual = function (spec, clause) {
 			for (var key in spec) {
 				if (spec.hasOwnProperty(key)) {
-					self.where(key).gte(spec[key]);
+					clause(key).gte(spec[key]);
 				}
 			}
 		};
 
-		var applyWhereLesserThan = function (spec) {
+		var applyLesserThan = function (spec, clause) {
 			for (var key in spec) {
 				if (spec.hasOwnProperty(key)) {
-					self.where(key).lt(spec[key]);
+					clause(key).lt(spec[key]);
 				}
 			}
 		};
 
-		var applyWhereLesserThanEqual = function (spec) {
+		var applyLesserThanEqual = function (spec, clause) {
 			for (var key in spec) {
 				if (spec.hasOwnProperty(key)) {
-					self.where(key).lte(spec[key]);
+					clause(key).lte(spec[key]);
 				}
 			}
 		};
 
-		var applyWhereNotEqualTo = function (spec) {
+		var applyNotEqual = function (spec, clause) {
 			for (var key in spec) {
 				if (spec.hasOwnProperty(key)) {
-					self.where(key).ne(parseWhereSpec(spec[key]));
+					clause(key).ne(parseWhereSpec(spec[key]));
 				}
 			}
 		};
 
-
-		var applyOptionals = function(optional) {
-			var items = [];
-
-			var populate = function (key, value, buildRegex) {
-				var
-					items = [],
-					item = {};
-
-				if (value instanceof Array && value.length) {
-					value.forEach(function (val) {
-						item = {};
-						item[key] = buildRegex(val);
-						items.push(item);
-					});
-
-					return items;
-				} else {
-					item[key] = buildRegex(value);
-
-					return item;
-				}
+		var applyRegex = function (spec, buildRegex, clause) {
+			var bulkApply = function (key, val) {
+				console.log('bulk applying key: ', key);
+				val.forEach(function (term) {
+					clause(key, term);
+				});
 			};
 
-			var parse = function(spec, buildRegex) {
-				var
-					parsedItems = null,
-					result = null;
-
-				if (!spec) {
-					return null;
-				}
-
-				for (var key in spec) {
-					if (spec.hasOwnProperty(key)) {
-						result = populate(key, spec[key], buildRegex);
-
-						if (result instanceof Array && result.length) {
-							parsedItems = result;
-						} else {
-							if (!parsedItems) {
-								parsedItems = [];
-							}
+			for (var key in spec) {
+				if (spec.hasOwnProperty(key)) {
+					var val = buildRegex(spec[key]);
 
-							parsedItems.push(result);
-						}
+					if (Array.isArray(val)) {
+						bulkApply(key, val);
+					} else {
+						clause(key, val);
 					}
 				}
-				return parsedItems;
-			};
-
-			items = parse(optional.contains, regexContains);
-			if (items && items instanceof Array && items.length) {
-				self.or(items);
-			}
-
-			items = parse(optional.endsWith, regexEndsWith);
-			if (items && items instanceof Array && items.length) {
-				self.or(items);
-			}
-
-			items = parse(optional.startsWith, regexStartsWith);
-			if (items && items instanceof Array && items.length) {
-				self.or(items);
-			}
-
-			items = parse(optional.exact, regexExact);
-			if (items && items instanceof Array && items.length) {
-				self.or(items);
 			}
 		};
 
@@ -156,63 +95,103 @@ module.exports = function(mongoose) {
 						}
 				}
 			}
+
 			return val;
 		};
 
 		var regexContains = function (val) {
+			if (Array.isArray(val) && val.length) {
+				return val.map(function (term) {
+					return regexContains(term);
+				});
+			}
+
 			if (typeof val === 'string') {
 				return new RegExp(sanitize(val), 'i');
 			}
 
 			return val;
 		};
 
-		/**
-		 * Assumes field type is a string
-		 **/
 		var regexEndsWith = function (val) {
+			if (Array.isArray(val) && val.length) {
+				return val.map(function (term) {
+					return regexEndsWith(term);
+				});
+			}
+
 			return new RegExp(sanitize(val) + '$', 'i');
 		};
 
 		var regexExact = function (val) {
-			if (isNaN(val) && typeof val === 'string') {
-				switch(val.toLowerCase()) {
-					case 'false' :
-						return false;
-					case 'true' :
-						return true;
-					case 'null' :
-						return null;
-					default :
-						return new RegExp('^' + sanitize(val) + '$', 'i');
-				}
+			if (Array.isArray(val) && val.length) {
+				return val.map(function (term) {
+					return regexExact(term);
+				});
+			}
+
+			val = parseWhereSpec(val);
+
+			if (typeof val === 'string') {
+				return new RegExp('^' + sanitize(val) + '$', 'i');
 			}
 
 			return val;
 		};
 
-		/**
-		 * Assumes field type is a string
-		 **/
 		var regexStartsWith = function (val) {
+			if (Array.isArray(val) && val.length) {
+				return val.map(function (term) {
+					return regexStartsWith(term);
+				});
+			}
+
 			return new RegExp('^' + sanitize(val), 'i');
 		};
 
 		// MANDATORY
-		applyWhere(mandatory.contains, regexContains);
-		applyWhere(mandatory.endsWith, regexEndsWith);
-		applyWhere(mandatory.startsWith, regexStartsWith);
-		applyWhere(mandatory.exact, regexExact);
-
-		applyWhereGreaterThan(mandatory.greaterThan || mandatory.gt || {});
-		applyWhereGreaterThanEqual(mandatory.greaterThanEqual || mandatory.gte || {});
-		applyWhereLesserThan(mandatory.lessThan || mandatory.lt || {});
-		applyWhereLesserThanEqual(mandatory.lessThanEqual || mandatory.lte || {});
-		applyWhereNotEqualTo(mandatory.notEqualTo || mandatory.ne || {});
-
+		applyRegex(mandatory.contains, regexContains, self.where);
+		applyRegex(mandatory.endsWith, regexEndsWith, self.where);
+		applyRegex(mandatory.startsWith, regexStartsWith, self.where);
+		applyRegex(mandatory.exact, regexExact, self.where);
+
+		applyGreaterThan(
+			mandatory.greaterThan || mandatory.gt || {},
+			self.where);
+		applyGreaterThanEqual(
+			mandatory.greaterThanEqual || mandatory.gte || {},
+			self.where);
+		applyLesserThan(
+			mandatory.lessThan || mandatory.lt || {},
+			self.where);
+		applyLesserThanEqual(
+			mandatory.lessThanEqual || mandatory.lte || {},
+			self.where);
+		applyNotEqual(
+			mandatory.notEqual || mandatory.notEqualTo || mandatory.ne || {},
+			self.where);
 
 		// OPTIONAL
-		applyOptionals(optional);
+		applyRegex(optional.contains, regexContains, self.or);
+		applyRegex(optional.endsWith, regexEndsWith, self.or);
+		applyRegex(optional.startsWith, regexStartsWith, self.or);
+		applyRegex(optional.exact, regexExact, self.or);
+
+		applyGreaterThan(
+			optional.greaterThan || optional.gt || {},
+			self.or);
+		applyGreaterThanEqual(
+			optional.greaterThanEqual || optional.gte || {},
+			self.or);
+		applyLesserThan(
+			optional.lessThan || optional.lt || {},
+			self.or);
+		applyLesserThanEqual(
+			optional.lessThanEqual || optional.lte || {},
+			self.or);
+		applyNotEqual(
+			optional.notEqual || optional.notEqualTo || optional.ne || {},
+			self.or);
 
 		return self;
 	};

diff --git a/readme.md b/readme.md
@@ -201,6 +201,7 @@ Filters can be used in three ways: mandatory, optional and keyword searches. Add
 * `greaterThanEqual` (or `gte`) - Matches documents where field value is greater than or equal to supplied number or Date value in query
 * `lessThan` (or `lt`) - Matches documents where field value is less than supplied number or Date value in query
 * `lessThanEqual` (or `lte`) - Matches documents where field value is less than or equal to supplied number or Date value in query
+* `notEqual` (or `ne`) - Matches documents where field value is not equal to the supplied value
 
 #### Mandatory