progress toward adding an and all and not

Author: justinbmeyer

src/serializers/basic-query-test.js

@@ -245,3 +245,23 @@ QUnit.skip("nested properties within ors", function(){
     }), "adds nested ands");
 });
 */
+
+
+QUnit.test("mongo things", function(assert) {
+    var query = {
+        filter: {
+			$and: [
+				{foo: "bar"},
+				{zed: "ted "}
+			]
+		}
+    };
+
+    var converter = makeBasicQueryConvert(EmptySchema);
+
+    var basicQuery = converter.hydrate(query);
+
+    var returnedQuery = converter.serializer.serialize(basicQuery);
+
+    assert.deepEqual(returnedQuery, query, "got back what we give");
+});

src/serializers/comparisons-test.js

@@ -1,10 +1,12 @@
 var QUnit = require("steal-qunit");
 var comparisons = require("./comparisons");
 var canReflect = require("can-reflect");
+var is = require("../types/comparisons");
+var ValuesNot = require("../types/values-not");
 
 QUnit.module("can-query-logic/serializers/comparisons");
 
-QUnit.test("hydrate and serialize", function(assert) {
+QUnit.test("hydrate and serialize with custom types that work with operators", function(assert) {
 	var Type = function(value){
 		this.value = value;
 	};
@@ -44,3 +46,17 @@ QUnit.test("unknown hydrator is called in all cases", function(assert) {
 
 	assert.deepEqual(hydrated, [1,2, "abc","x","y"], "hydrated called with the right stuff");
 });
+
+
+QUnit.only("$not and $all can work recursively", function(assert){
+
+
+	var hydrated = comparisons.hydrate( {$not: {$all: ['def']}}, function(value){
+		return value;
+	} );
+
+	console.log(hydrated);
+
+	assert.ok(hydrated instanceof ValuesNot, "is an instance");
+
+})

src/serializers/comparisons.js

@@ -1,6 +1,7 @@
 var is = require("../types/comparisons");
 var Serializer = require("../serializer");
 var canReflect = require("can-reflect");
+var ValuesNot = require("../types/values-not");
 
 function makeNew(Constructor) {
 	return function(value){
@@ -47,6 +48,13 @@ addHydrateFrom("$gte", makeNew(is.GreaterThanEqual));
 addHydrateFromValues("$in", makeNew(is.In));
 addHydrateFrom("$lt", makeNew(is.LessThan));
 addHydrateFrom("$lte", makeNew(is.LessThanEqual));
+
+addHydrateFromValues("$all", makeNew(is.All));
+
+hydrateMap["$not"] = function(value, unknownHydrator) {
+	return new ValuesNot(hydrateValue(value["$not"], unknownHydrator));
+};
+
 addHydrateFromValues("$nin", makeNew(is.GreaterThan));
 
 
@@ -83,41 +91,44 @@ var serializer = new Serializer([
 	}]*/
 ]);
 
-module.exports = {
-	hydrate: function(value, hydrateUnknown){
-		if(!hydrateUnknown) {
-			hydrateUnknown = function(){
-				throw new Error("can-query-logic doesn't recognize operator: "+JSON.stringify(value));
-			}
+function hydrateValue(value, hydrateUnknown){
+	if(!hydrateUnknown) {
+		hydrateUnknown = function(){
+			throw new Error("can-query-logic doesn't recognize operator: "+JSON.stringify(value));
 		}
-		if(Array.isArray(value)) {
-			return new is.In(value.map(function(value){
-				return hydrateUnknown(value);
-			}));
-		}
-		else if(value && typeof value === "object") {
-			var keys = Object.keys(value);
-			var allKeysAreComparisons = keys.every(function(key){
-				return hydrateMap[key]
+	}
+	if(Array.isArray(value)) {
+		return new is.In(value.map(function(value){
+			return hydrateUnknown(value);
+		}));
+	}
+	else if(value && typeof value === "object") {
+		var keys = Object.keys(value);
+		var allKeysAreComparisons = keys.every(function(key){
+			return hydrateMap[key]
+		});
+		if(allKeysAreComparisons) {
+			var andClauses = keys.map(function(key){
+				var part = {};
+				part[key] = value[key];
+				var hydrator = hydrateMap[key];
+				return hydrator(part, hydrateUnknown);
 			});
-			if(allKeysAreComparisons) {
-				var andClauses = keys.map(function(key){
-					var part = {};
-					part[key] = value[key];
-					var hydrator = hydrateMap[key];
-					return hydrator(part, hydrateUnknown);
-				});
-				if(andClauses.length > 1) {
-					return new is.And(andClauses);
-				} else {
-					return andClauses[0];
-				}
+			if(andClauses.length > 1) {
+				return new is.And(andClauses);
 			} else {
-				return hydrateUnknown(value);
+				return andClauses[0];
 			}
 		} else {
-			return new is.In([hydrateUnknown(value)]);
+			return hydrateUnknown(value);
 		}
-	},
+	} else {
+		return new is.In([hydrateUnknown(value)]);
+	}
+}
+
+module.exports = {
+	// value - something from a query, for example {$in: [1,2]}
+	hydrate: hydrateValue,
 	serializer: serializer
 };

src/types/comparisons-test.js

@@ -1,6 +1,7 @@
 var compare = require("./comparisons");
 var set = require("../set");
 var is = compare;
+var ValuesNot = require("./values-not");
 
 QUnit.module("can-query-logic/types/comparisons")
 
@@ -3968,3 +3969,43 @@ QUnit.test("Able to do membership, union, difference with $in", function(assert)
 	    new is.And([gt1980, lte1990]),
 	    "difference");*/
 });
+
+QUnit.test("All on arrays", function(assert){
+
+	var arrayHasAbc = new is.All(["abc"]);
+
+	assert.equal( arrayHasAbc.isMember(["abc"]), true );
+	assert.equal( arrayHasAbc.isMember(["abc", "def"]), true );
+	assert.equal( arrayHasAbc.isMember(["def"]), false );
+	assert.equal( arrayHasAbc.isMember([]), false );
+
+	var hasAbcAndDef = new is.And([
+	    new is.All(["abc"]),
+	    new is.All(["def"])
+	]);
+
+
+	assert.equal( hasAbcAndDef.isMember(["abc"]), false );
+	assert.equal( hasAbcAndDef.isMember(["abc", "def"]), true );
+	assert.equal( hasAbcAndDef.isMember(["def"]), false );
+	assert.equal( hasAbcAndDef.isMember([]), false );
+
+	var hasAbcAndNotDef = new is.And([
+	    new is.All(["abc"]),
+	    new ValuesNot( new is.All(["def"]) )
+	]);
+
+	assert.equal( hasAbcAndNotDef.isMember(["abc"]), true );
+	assert.equal( hasAbcAndNotDef.isMember(["abc", "def"]), false );
+	assert.equal( hasAbcAndNotDef.isMember(["def"]), false );
+	assert.equal( hasAbcAndNotDef.isMember([]), false );
+	// Future tests
+	// arrayHasAbc.isMember(null), false
+	//
+	// {$all: ["10-20-22"]}.isMember( ["yesterday"])
+	// new is.All([new DateStrSet(date1990)]).isMember(new DateStrSet(date1990))
+	/*
+	*/
+
+
+})

src/types/comparisons.js

@@ -45,13 +45,25 @@ var comparisons = {
 	// These are all value comparisons.
 	Or: function ValueOr(ors) {
 		this.values = ors;
+	},
+	All: function(values){
+		this.values = values;
 	}
 };
 
 comparisons.Or.prototype.orValues = function() {
 	return this.values;
 };
 
+comparisons.All.test = function(allValues, recordValues) {
+
+	return allValues.every(function(allValue) {
+		return recordValues.some(function(recordValue){
+			var values = set.ownAndMemberValue(allValue, recordValue);
+			return values.own === values.member;
+		});
+	});
+}
 
 comparisons.In.test = function(values, b) {
 	return values.some(function(value) {
@@ -115,7 +127,7 @@ function isMemberThatUsesTest(value) {
 function isMemberThatUsesTestOnValues(value) {
 	return this.constructor.test(this.values, value);
 }
-[comparisons.In, comparisons.NotIn].forEach(function(Type) {
+[comparisons.In, comparisons.NotIn, comparisons.All].forEach(function(Type) {
 	Type.prototype.isMember = isMemberThatUsesTestOnValues;
 });
 

src/types/values-not.js

@@ -82,4 +82,14 @@ set.defineComparison(Identity, NotIdentity,{
     }
 });
 
+NotIdentity.prototype.isMember = function(value){
+	if(this.value  && typeof this.value.isMember === "function") {
+		return !this.value.isMember(value);
+	} else {
+		var values = set.ownAndMemberValue(this.value, value)
+		return values.own !== values.member;
+	}
+
+}
+
 module.exports = keysLogic.Not = NotIdentity;