Adds most code for $and, $all, $not

matthewp · matthewp · commit 265e11954b5b · 2019-07-18T13:25:30.000-04:00
This implements $and, $all, and $not. Needs more tests and logic for
comparisons between these types.
diff --git a/.editorconfig b/.editorconfig
@@ -4,3 +4,8 @@ end_of_line = LF
 indent_style = tab
 trim_trailing_whitespace = false
 insert_final_newline = true
+indent_size = 4
+
+[{*.json,*.yml,*.md}]
+indent_style = space
+indent_size = 2
diff --git a/can-query-logic-test.js b/can-query-logic-test.js
@@ -4,13 +4,15 @@ require("./src/types/make-real-number-range-inclusive-test");
 require("./src/types/comparisons-test");
 require("./src/types/and-or-not-test");
 require("./src/types/values-or-test");
+require("./src/types/basic-query-test");
 require("./src/types/basic-query-sorting-test");
 require("./src/types/basic-query-filter-from-test");
 require("./src/types/basic-query-merge-test");
 require("./src/serializers/basic-query-test");
 require("./src/serializers/comparisons-test");
 require("./src/types/make-maybe-test");
 require("./src/types/make-enum-test");
+require("./src/types/values-and-test");
 require("./compat/compat-test");
 require("./test/special-comparison-logic-test");
 require("./test/make-enum-logic-test");
diff --git a/package.json b/package.json
@@ -29,9 +29,6 @@
     "donejs-plugin"
   ],
   "steal": {
-    "configDependencies": [
-      "live-reload"
-    ],
     "npmIgnore": [
       "testee",
       "generator-donejs",
diff --git a/src/serializers/basic-query-test.js b/src/serializers/basic-query-test.js
@@ -5,6 +5,7 @@ var logicTypes = require("../types/and-or-not");
 var is = require("../types/comparisons");
 var makeMaybe = require("../types/make-maybe");
 var testHelpers = require("can-test-helpers");
+var ValuesAnd = require("../types/values-and");
 
 QUnit.module("can-query-logic/serializers/basic-query");
 
@@ -246,20 +247,21 @@ QUnit.skip("nested properties within ors", function(){
 });
 */
 
-
-QUnit.test("mongo things", function(assert) {
-    var query = {
-        filter: {
+QUnit.test("Complex queries with nested $not, $all", function(assert) {
+	var query = {
+		filter: {
 			$and: [
-		      {tags: {$all: ['sbux']}},
-		      {tags: {$not: {$all: ['dfw']}}}
-		  ]
+				{tags: {$all: ['sbux']}},
+				{tags: {$not: {$all: ['dfw']}}}
+			]
 		}
-    };
+	};
 
-    var converter = makeBasicQueryConvert(EmptySchema);
+	var converter = makeBasicQueryConvert(EmptySchema);
+	var basicQuery = converter.hydrate(query);
 
-    var basicQuery = converter.hydrate(query);
+	assert.ok(basicQuery.filter instanceof ValuesAnd);
 
-    assert(basicQuery.filter instanceof )
+	var res = converter.serializer.serialize(basicQuery);
+	assert.deepEqual(res, query);
 });
diff --git a/src/serializers/basic-query.js b/src/serializers/basic-query.js
@@ -27,8 +27,11 @@ function getSchemaProperties(value) {
 }
 
 function hydrateFilter(values, schemaProperties, hydrateUnknown) {
-	if (values && typeof values === "object" && ("$or" in values)) {
+	var valuesIsObject = values && typeof values === "object";
+	if (valuesIsObject && ("$or" in values)) {
 		return hydrateOrs(values.$or, schemaProperties, hydrateUnknown);
+	} else if(valuesIsObject && ("$and" in values)) {
+		return hydrateAnds(values.$and, schemaProperties, hydrateUnknown);
 	} else {
 		return hydrateAndValues(values, schemaProperties, hydrateUnknown);
 	}
@@ -194,6 +197,13 @@ function hydrateOrs(values, schemaProperties, hydrateUnknown) {
 	return new BasicQuery.Or(comparisons);
 }
 
+function hydrateAnds(values, schemaProperties, hydrateUnknown) {
+	var comparisons = values.map(function(value) {
+		return hydrateAndValues(value, schemaProperties, hydrateUnknown);
+	});
+	return new BasicQuery.And(comparisons);
+}
+
 function recursivelyAddOrs(ors, value, serializer, key){
     value.orValues().forEach(function(orValue){
         if(typeof orValue.orValues === "function") {
@@ -217,6 +227,14 @@ module.exports = function(schema) {
 				return serializer(value);
 			});
 		}],
+		[BasicQuery.And, function(and, serializer) {
+			return { $and: and.values.map(function(value) {
+				return serializer(value);
+			}) };
+		}],
+		[BasicQuery.Not, function(nots, serializer) {
+			return { $not: serializer(nots.value) };
+		}],
 		// this destructures ANDs with OR-like clauses
 		[BasicQuery.KeysAnd, function(and, serializer) {
 			var ors = [];
@@ -230,6 +248,7 @@ module.exports = function(schema) {
 					result[key] = serializer(value);
 				}
 			});
+
 			if (ors.length) {
 				if (ors.length === 1) {
 					return ors[0];
diff --git a/src/serializers/comparisons-test.js b/src/serializers/comparisons-test.js
@@ -34,7 +34,6 @@ QUnit.test("hydrate and serialize with custom types that work with operators", f
 });
 
 QUnit.test("unknown hydrator is called in all cases", function(assert) {
-
 	var hydrated = [];
 	var addToHydrated = function(value){
 		hydrated.push(value);
@@ -48,15 +47,11 @@ QUnit.test("unknown hydrator is called in all cases", function(assert) {
 });
 
 
-QUnit.only("$not and $all can work recursively", function(assert){
-
+QUnit.test("$not and $all can work recursively", function(assert){
 	// WHat if {$not: 1} //-> is.NotIn([1]) | new is.ValuesNot(new is.In([1]))
 	var hydrated = comparisons.hydrate( {$not: {$all: ['def']}}, function(value){
 		return value;
 	} );
 
-	console.log(hydrated);
-
 	assert.ok(hydrated instanceof ValuesNot, "is an instance");
-
-})
+});
diff --git a/src/serializers/comparisons.js b/src/serializers/comparisons.js
@@ -2,6 +2,7 @@ var is = require("../types/comparisons");
 var Serializer = require("../serializer");
 var canReflect = require("can-reflect");
 var ValuesNot = require("../types/values-not");
+var ValuesAnd = require("../types/values-and");
 
 function makeNew(Constructor) {
 	return function(value){
@@ -58,9 +59,6 @@ hydrateMap["$not"] = function(value, unknownHydrator) {
 addHydrateFromValues("$nin", makeNew(is.GreaterThan));
 
 
-
-
-
 var serializer = new Serializer([
 	[is.In,function(isIn, serialize){
 		return isIn.values.length === 1 ?
@@ -81,7 +79,8 @@ var serializer = new Serializer([
 			canReflect.assignMap(obj, serialize(clause) );
 		});
 		return obj;
-	}]
+	}],
+	[is.All, function(all, serialize) { return {$all: serialize(all.values)}}]
 	/*[is.Or, function(or, serialize){
 		return {
 			$or: or.values.map(function(value){
diff --git a/src/types/and-or-not.js b/src/types/and-or-not.js
@@ -1,9 +1,11 @@
 var ValuesOr = require("./values-or");
 var ValuesNot = require("./values-not");
+var ValuesAnd = require("./values-and");
 var KeysAnd = require("./keys-and");
 
 module.exports = {
     KeysAnd: KeysAnd,
     ValuesOr: ValuesOr,
-    ValuesNot: ValuesNot
+    ValuesNot: ValuesNot,
+	ValuesAnd: ValuesAnd
 };
diff --git a/src/types/basic-query-test.js b/src/types/basic-query-test.js
@@ -0,0 +1,28 @@
+var BasicQuery = require("./basic-query");
+var canSymbol = require("can-symbol");
+var QUnit = require("steal-qunit");
+var KeysAnd = require("./keys-and");
+var ValuesAnd = require("./values-and");
+
+QUnit.module("can-query-logic/types/basic-query filterMembersAndGetCount");
+
+QUnit.test("Able to filter on a universal set", function(assert) {
+	var parent = new BasicQuery({
+		filter: new KeysAnd({})
+	})
+	var bData = [{},{}];
+
+	var FooType = function(value) { this.value = value; };
+	FooType.prototype.isMember = function() {
+		return true;
+	};
+
+	var root = new BasicQuery({
+	    filter: new ValuesAnd([
+	    	new FooType()
+	    ])
+	});
+
+	var res = root.filterMembersAndGetCount(bData, parent);
+	assert.equal(res.count, 2, "got all members");
+});
diff --git a/src/types/basic-query.js b/src/types/basic-query.js
@@ -11,7 +11,8 @@ var isMemberSymbol = canSymbol.for("can.isMember");
 // TYPES FOR FILTERING
 var KeysAnd = andOrNot.KeysAnd,
 	Or = andOrNot.ValuesOr,
-	Not = andOrNot.ValuesNot;
+	Not = andOrNot.ValuesNot,
+	And = andOrNot.ValuesAnd;
 
 // TYPES FOR PAGINATION
 var RecordRange = makeRealNumberRangeInclusive(0, Infinity);
@@ -155,6 +156,7 @@ function BasicQuery(query) {
 BasicQuery.KeysAnd = KeysAnd;
 BasicQuery.Or = Or;
 BasicQuery.Not = Not;
+BasicQuery.And = And;
 BasicQuery.RecordRange = RecordRange;
 BasicQuery.makeSort = makeSort;
 
@@ -170,7 +172,8 @@ canReflect.assignMap(BasicQuery.prototype, {
 	},
 	filterMembersAndGetCount: function(bData, parentQuery) {
 		if (parentQuery) {
-			if (!set.isSubset(this, parentQuery)) {
+			if (!set.isEqual(set.UNIVERSAL, parentQuery.filter) &&
+				!set.isSubset(this, parentQuery)) {
 				throw new Error("can-query-logic: Unable to get members from a set that is not a superset of the current set.");
 			}
 		} else {
diff --git a/src/types/comparisons-test.js b/src/types/comparisons-test.js
@@ -3825,6 +3825,24 @@ var tests = {
 				"other directional holes"
 			);
 		}
+	},
+	UNIVERSAL_All: {
+		difference: function(assert) {
+			var all = new is.All(["test"]);
+			assert.deepEqual(
+				set.difference(set.UNIVERSAL, all),
+				set.UNKNOWABLE
+			);
+		}
+	},
+	All_UNIVERSAL: {
+		difference: function(assert) {
+			var all = new is.All(["test"]);
+			assert.deepEqual(
+				set.difference(all, set.UNIVERSAL),
+				set.EMPTY
+			);
+		}
 	}
 };
 
diff --git a/src/types/comparisons.js b/src/types/comparisons.js
@@ -56,14 +56,13 @@ comparisons.Or.prototype.orValues = function() {
 };
 
 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) {
@@ -934,7 +933,6 @@ var comparators = {
 			return set.union(inverseFirst, inverseSecond);
 		}
 	},
-
 	Or_Or: {
 		// (a ∪ b) ∪ (c ∪ d)
 		union: function(or1, or2) {
@@ -993,6 +991,16 @@ var comparators = {
 			return set.intersection(inverseFirst, inverseSecond);
 		}
 	},
+	UNIVERSAL_All: {
+		difference: function() {
+			return set.UNKNOWABLE;
+		}
+	},
+	All_UNIVERSAL: {
+		difference: function() {
+			return set.EMPTY;
+		}
+	}
 };
 
 // Registers all the comparisons above
diff --git a/src/types/make-maybe-test.js b/src/types/make-maybe-test.js
@@ -24,7 +24,7 @@ ComparisonSet.prototype.valueOf = function() {
 var MaybeDateStringSet = makeMaybe([null, undefined], DateStringSet);
 
 
-QUnit.test("construtor normalizes", function(assert) {
+QUnit.test("constructor normalizes", function(assert) {
 	var isNull_3 = new MaybeDateStringSet({
 		range: new is.In([null, 3])
 	});
diff --git a/src/types/values-and-test.js b/src/types/values-and-test.js
@@ -0,0 +1,17 @@
+var QUnit = require("steal-qunit");
+var KeysAnd = require("./keys-and");
+var ValuesAnd = require("./values-and");
+var ValuesNot = require("./values-not");
+var is = require("./comparisons");
+
+QUnit.module("can-query-logic/types/values-and");
+
+QUnit.test("works", function(assert) {
+	var allAndNot = new ValuesAnd([
+		new KeysAnd({tags: new is.All(['sbux']) }),
+		new KeysAnd({tags: new ValuesNot( new is.All(['dfw']) )  })
+	]);
+
+	assert.equal(allAndNot.isMember({tags:["sbux"]}), true);
+	assert.equal(allAndNot.isMember({tags:["sbux", "dfw"]}), false);
+});
diff --git a/src/types/values-and.js b/src/types/values-and.js
@@ -0,0 +1,22 @@
+var keysLogic = require("./types");
+var set = require("../set");
+
+function ValuesAnd(values) {
+	this.values = values;
+}
+
+ValuesAnd.prototype.isMember = function(props) {
+	return this.values.every(function(value){
+            return value && value.isMember ?
+                value.isMember( props ) : value === props;
+    });
+};
+
+// Or comparisons
+set.defineComparison(set.UNIVERSAL, ValuesAnd, {
+    difference: function(){
+        return set.UNDEFINABLE;
+    }
+});
+
+module.exports = keysLogic.ValuesAnd = ValuesAnd;
