EAGLESIX-3190: ParsedDeps: fix issues w/ 2.6.5 port, add test for nested case

lib/pipeline/ParsedDeps.js

@@ -18,7 +18,6 @@ var Value = require("./Value");
 
 /**
  * Extracts fields from the input into a new Document, based on the caller.
- *
  * @method extractFields
  * @param {Object} input	The JSON object to extract from
  * @return {Document}
@@ -28,59 +27,65 @@ proto.extractFields = function extractFields(input) {
 };
 
 /**
- * Private: Handles array-type values for extractFields()
- *
+ * Handles array-type values for extractFields()
+ * Mutually recursive with arrayHelper
  * @method _arrayHelper
+ * @private
  * @param {Object} array	Array to iterate over
  * @param {Object} neededFields
  * @return {Array}
  */
 proto._arrayHelper = function _arrayHelper(array, neededFields) {
 	var values = [];
+	for (var i = 0, l = array.length; i < l; i++) {
+		var jsonElement = array[i];
+		if (Value.getType(jsonElement) === "Object") {
+			var sub = this._documentHelper(jsonElement, neededFields);
+			values.push(sub);
+		}
 
-	for (var i = 0; i < array.length; i++) {
-		var it = array[i];
-		if (it instanceof Array)
-			values.push(_arrayHelper(it, neededFields));
-		else if (it instanceof Object)
-			values.push(proto._documentHelper(it, neededFields));
+		if (Value.getType(jsonElement) === "Array") {
+			values.push(this._arrayHelper(jsonElement, neededFields));
+		}
 	}
 
 	return values;
 };
 
 /**
- * Private: Handles object-type values for extractFields()
- *
+ * Handles object-type values for extractFields()
  * @method _documentHelper
+ * @private
  * @param {Object} json	Object to iterate over and filter
  * @param {Object} neededFields	Fields to not exclude
  * @return {Document}
  */
 proto._documentHelper = function _documentHelper(json, neededFields) {
-	var doc = {};
+	var md = {};
 
-	for (var fieldName in json) {
+	for (var fieldName in json) { //jshint ignore:line
 		var jsonElement = json[fieldName],
 			isNeeded = neededFields[fieldName];
 
 		if (isNeeded === undefined)
 			continue;
 
-		if (Value.getType(isNeeded) === 'boolean') {
-			doc[fieldName] = jsonElement;
+		if (typeof isNeeded === "boolean") {
+			md[fieldName] = jsonElement;
 			continue;
 		}
 
-		if (!isNeeded instanceof Object) throw new Error("dassert failure");
+		if (!(isNeeded instanceof Object)) throw new Error("dassert failure");
+
+		if (Value.getType(jsonElement) === "Object") {
+			var sub = this._documentHelper(jsonElement, isNeeded);
+			md[fieldName] = sub;
+		}
 
-		if (Value.getType(isNeeded) === 'object') {
-			if (jsonElement instanceof Array)
-				doc[fieldName] = proto._arrayHelper(jsonElement, isNeeded);
-			if (jsonElement instanceof Object)
-				doc[fieldName] = proto._documentHelper(jsonElement, isNeeded);
+		if (Value.getType(jsonElement) === "Array") {
+			md[fieldName] = this._arrayHelper(jsonElement, isNeeded);
 		}
 	}
 
-	return doc;
+	return md;
 };

test/lib/pipeline/ParsedDeps.js

@@ -1,68 +1,86 @@
 "use strict";
+if (!module.parent) return require.cache[__filename] = 0, (new(require("mocha"))).addFile(__filename).ui("exports").run(process.exit); //jshint ignore:line
 var assert = require("assert"),
 	ParsedDeps = require("../../../lib/pipeline/ParsedDeps");
 
-module.exports = {
-	"ParsedDeps": {
-		"#extractFields": {
-			"should be able to convert a document to its projected form": function() {
-				var deps = {'a': true, 'b': true},
-					doc = {a:23, b:64, c:92},
-					parse = new ParsedDeps(deps);
-
-				var proj = parse.extractFields(doc);
-				assert.deepEqual({a:23,b:64}, proj);
-			}
+exports.ParsedDeps = {
+
+	"#extractFields": {
+
+		"should be able to convert a document to its projected form": function() {
+			var deps = {a:true, b:true},
+				doc = {a:23, b:64, c:92},
+				proj = new ParsedDeps(deps).extractFields(doc),
+				expected = {a:23,b:64};
+			assert.deepEqual(proj, expected);
 		},
-		"#_documentHelper": {
-			"should skip fields that are not needed": function() {
-				var json = {'foo':'bar'},
-					neededFields = {},
-					parse = new ParsedDeps(),
-					expected = {};
-				assert.deepEqual(expected, parse._documentHelper(json, neededFields));
-			},
-			"should return values that are booleans": function() {
-				var json = {'foo':'bar'},
-					neededFields = {'foo':true},
-					parse = new ParsedDeps(),
-					expected = {'foo':'bar'};
-				assert.deepEqual(expected, parse._documentHelper(json, neededFields));
-			},
-			"should call _arrayHelper on values that are arrays": function() {
-				var json = {'foo':[{'bar':'baz'}], 'a': 'b'},
-					neededFields = {'foo':true},
-					parse = new ParsedDeps(),
-					expected = {'foo':[{bar:'baz'}]};
-				assert.deepEqual(expected, parse._documentHelper(json, neededFields));
-			},
-			"should recurse on values that are objects": function() {
-				var json = {'foo':{'bar':'baz'}},
-					neededFields = {'foo':true},
-					parse = new ParsedDeps(),
-					expected = {'foo':{'bar':'baz'}};
-				assert.deepEqual(expected, parse._documentHelper(json, neededFields));
-			}
+
+		"should extract fields for nested objects": function() {
+			var deps = {a:{b:true}},
+				doc = {a:{b:[1,2,3]},ignoreThisOne:123},
+				proj = new ParsedDeps(deps).extractFields(doc),
+				expected = {a:{b:[1,2,3]}};
+			assert.deepEqual(proj, expected);
+		},
+
+	},
+
+	"#_documentHelper": {
+
+		"should skip fields that are not needed": function() {
+			var json = {"foo":"bar"},
+				neededFields = {},
+				parse = new ParsedDeps(),
+				expected = {};
+			assert.deepEqual(parse._documentHelper(json, neededFields), expected);
+		},
+
+		"should return values that are booleans": function() {
+			var json = {"foo":"bar"},
+				neededFields = {"foo":true},
+				parse = new ParsedDeps(),
+				expected = {"foo":"bar"};
+			assert.deepEqual(parse._documentHelper(json, neededFields), expected);
+		},
+
+		"should call _arrayHelper on values that are arrays": function() {
+			var json = {"foo":[{"bar":"baz"}], "a": "b"},
+				neededFields = {"foo":true},
+				parse = new ParsedDeps(),
+				expected = {"foo":[{bar:"baz"}]};
+			assert.deepEqual(parse._documentHelper(json, neededFields), expected);
 		},
-		"#_arrayHelper": {
-			"should call _documentHelper on values that are objects": function() {
-				var array = [{'foo':'bar'}],
-					neededFields = {'foo':true},
-					parse = new ParsedDeps(),
-					expected = [{foo:'bar'}];
-				assert.deepEqual(expected, parse._arrayHelper(array, neededFields));
-			},
-			"should recurse on values that are arrays": function() {
-				var array = [[{'foo':'bar'}]],
-					neededFields = {'foo':true},
-					parse = new ParsedDeps(),
-					expected = [[{'foo':'bar'}]];
-
-				var actual = parse._arrayHelper(array, neededFields);
-				assert.deepEqual(actual, expected);
-			}
-		}
-	}
-};
 
-if (!module.parent)(new(require("mocha"))()).ui("exports").reporter("spec").addFile(__filename).run();
+		"should recurse on values that are objects": function() {
+			var json = {"foo":{"bar":"baz"}},
+				neededFields = {"foo":true},
+				parse = new ParsedDeps(),
+				expected = {"foo":{"bar":"baz"}};
+			assert.deepEqual(parse._documentHelper(json, neededFields), expected);
+		},
+
+	},
+
+	"#_arrayHelper": {
+
+		"should call _documentHelper on values that are objects": function() {
+			var array = [{"foo":"bar"}],
+				neededFields = {"foo":true},
+				parse = new ParsedDeps(),
+				expected = [{foo:"bar"}];
+			assert.deepEqual(parse._arrayHelper(array, neededFields), expected);
+		},
+
+		"should recurse on values that are arrays": function() {
+			var array = [[{"foo":"bar"}]],
+				neededFields = {"foo":true},
+				parse = new ParsedDeps(),
+				expected = [[{"foo":"bar"}]];
+
+			var actual = parse._arrayHelper(array, neededFields);
+			assert.deepEqual(actual, expected);
+		},
+
+	},
+
+};