Fix JSHint config and linting errors

Author: Chasen Le Hara

compat/compat.js

@@ -76,7 +76,7 @@ var set = {
                 if(mutators[prop]) {
                     mutators[prop].push(value[prop]);
                 } else {
-                    throw new Error("can-query-logic: This type of configuration is not supported. Please use can-query-logic directly.")
+                    throw new Error("can-query-logic: This type of configuration is not supported. Please use can-query-logic directly.");
                 }
 
             }
@@ -123,7 +123,7 @@ var set = {
                 var filter = data.filter || {};
                 if(hasKey(filter, {
                     "$ne": true,
-                    "$in": function(val){ return val["$in"]; }
+                    "$in": function(val){ return val.$in; }
                 })) {
                     return SET.UNDEFINABLE;
                 }
@@ -167,7 +167,7 @@ var set = {
                     return query;
                 }
             }
-        }
+        };
     },
     props: {
 

compat/prop_tests/sort_test.js

@@ -141,12 +141,12 @@ QUnit.test('set.isSubset with range', function(assert) {
 	// same
 	// right
 	// left
-	var addSort = function(set, value){
+	var addSort = function(set, value) {
 		set.sort = value;
 	};
 
 	var sort = {
-		left: function(setA, setB) {
+		left: function(setA) {
 			addSort(setA, "prop");
 		},
 		right: function(setA, setB) {
@@ -167,46 +167,46 @@ QUnit.test('set.isSubset with range', function(assert) {
 	};
 
 	var range = {
-		left: function(setA,setB){
+		left: function(setA) {
 			addRange(setA, 0,9);
 		},
-		right: function(setA,setB){
+		right: function(setA,setB) {
 			addRange(setB, 0,9);
 		},
-		same: function(setA,setB){
+		same: function(setA,setB) {
 			addRange(setA, 0,9);
 			addRange(setB, 0,9);
 		},
-		superLeft: function(setA,setB){
+		superLeft: function(setA,setB) {
 			addRange(setA, 0,9);
 			addRange(setB, 3,7);
 		},
-		superRight: function(setA,setB){
+		superRight: function(setA,setB) {
 			addRange(setB, 0,9);
 			addRange(setA, 3,7);
 		}
 	};
 
 	var sets = {
-		same: function(setA, setB){ },
-		superLeft: function(setA, setB){
+		same: function() { },
+		superLeft: function(setA, setB) {
 			setB.type = "apples";
 		},
-		superRight: function(setA, setB){
+		superRight: function(setA) {
 			setA.type = "apples";
 		}
 	};
 
 
-	var make = function(){
+	var make = function() {
 		var setA = {},
 			setB = {};
-		canReflect.eachIndex(arguments, function(method){
+		canReflect.eachIndex(arguments, function(method) {
 			method(setA, setB);
 		});
 		return {left: setA, right: setB};
 	};
-	var assertSubset = function(methods, result){
+	var assertSubset = function(methods, result) {
 		var sets = make.apply(null, methods);
 		assert.equal( algebra.isSubset(sets.left, sets.right), result, JSON.stringify(sets.left)+" ⊂ "+JSON.stringify(sets.right)+" = "+result );
 	};

doc/examples/date-string-example.js

@@ -1,4 +1,4 @@
-import {DefineMap, QueryLogic, Reflect as canReflect} from "can";
+import {DefineMap, QueryLogic } from "can";
 
 class DateStringSet {
 	constructor(value){

doc/examples/searchable-todo-example.js

@@ -96,5 +96,4 @@ const result = queryLogic.filterMembers({
   filter: {name: "important"}
 }, todos);
 
-console.log( todos ); //->[{id: 1, name: "important meeting"},{id: 3, name: "find out what important means"}]
-
+console.log( result ); //->[{id: 1, name: "important meeting"},{id: 3, name: "find out what important means"}]

package.json

@@ -19,7 +19,7 @@
     "postpublish": "git push --tags && git push",
     "testee": "testee test.html --browsers firefox",
     "test": "npm run jshint && npm run testee",
-    "jshint": "jshint ./*.js src/**.js --config",
+    "jshint": "jshint --config .jshintrc --exclude ./node_modules,./dist .",
     "release:patch": "npm version patch && npm publish",
     "release:minor": "npm version minor && npm publish",
     "release:major": "npm version major && npm publish",

src/serializers/basic-query-test.js

@@ -54,7 +54,7 @@ QUnit.test("nested properties", function(assert) {
 
 QUnit.test("$or with the same types unify into maybe", function(assert) {
 
-    var MaybeSet = makeMaybe([null])
+    var MaybeSet = makeMaybe([null]);
 
     var converter = makeBasicQueryConvert({
         identity: ["id"],
@@ -222,7 +222,7 @@ QUnit.test("basicquery with no sort", function(assert) {
 	});
 	var basicQuery = converter.hydrate(query);
 
-	var objs = [{id: 0}, {id: 2}]
+	var objs = [{id: 0}, {id: 2}];
 	var item = {id: 1};
 
 	var res = basicQuery.index(item, objs);

src/serializers/comparisons-test.js

@@ -1,7 +1,6 @@
 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");
@@ -15,7 +14,7 @@ QUnit.test("hydrate and serialize with custom types that work with operators", f
 		"can.serialize": function(){
 			return this.value;
 		}
-	})
+	});
 
 	var hydrated = comparisons.hydrate({$in: [1,2]}, function(value){
 		return new Type(value);
@@ -37,7 +36,7 @@ QUnit.test("unknown hydrator is called in all cases", function(assert) {
 	var hydrated = [];
 	var addToHydrated = function(value){
 		hydrated.push(value);
-	}
+	};
 
 	comparisons.hydrate({$in: [1,2]}, addToHydrated);
 	comparisons.hydrate("abc", addToHydrated);

src/serializers/comparisons.js

@@ -2,10 +2,9 @@ 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){
+	return function(value) {
 		return new Constructor(value);
 	};
 }
@@ -24,7 +23,7 @@ function addHydrateFromValues(key, hydrate) {
 	hydrateMap[key] = function(value, unknownHydrator) {
 		var clones = value[key];
 		if(unknownHydrator) {
-			clones = clones.map(function(value){
+			clones = clones.map(function(value) {
 				return unknownHydrator(value);
 			});
 		}
@@ -37,10 +36,10 @@ function addHydrateFromValues(key, hydrate) {
 }
 
 // https://docs.mongodb.com/manual/reference/operator/query-comparison/
-addHydrateFrom("$eq", function(value){
+addHydrateFrom("$eq", function(value) {
 	return new is.In([value]);
 });
-addHydrateFrom("$ne", function(value){
+addHydrateFrom("$ne", function(value) {
 	return new is.NotIn([value]);
 });
 
@@ -63,9 +62,9 @@ var oppositeTypeMap = {
 	NotIn: { Type: is.In, prop: "values" }
 };
 
-hydrateMap["$not"] = function(value, unknownHydrator) {
+hydrateMap.$not = function(value, unknownHydrator) {
 	// Many nots can be hydrated to their opposite.
-	var hydratedValue = hydrateValue(value["$not"], unknownHydrator);
+	var hydratedValue = hydrateValue(value.$not, unknownHydrator);
 	var typeName = hydratedValue.constructor.name;
 
 	if(oppositeTypeMap[typeName]) {
@@ -83,54 +82,58 @@ addHydrateFromValues("$nin", makeNew(is.NotIn));
 
 
 var serializer = new Serializer([
-	[is.In,function(isIn, serialize){
+	[is.In,function(isIn, serialize) {
 		return isIn.values.length === 1 ?
 			serialize(isIn.values[0]) :
 			{$in: isIn.values.map(serialize)};
 	}],
-	[is.NotIn,function(notIn, serialize){
+	[is.NotIn,function(notIn, serialize) {
 		return notIn.values.length === 1 ?
 			{$ne: serialize(notIn.values[0])} : {$nin: notIn.values.map(serialize)};
 	}],
-	[is.GreaterThan, function(gt, serialize){ return {$gt: serialize(gt.value) }; }],
-	[is.GreaterThanEqual, function(gte, serialize){ return {$gte: serialize(gte.value) }; }],
-	[is.LessThan, function(lt, serialize){ return {$lt: serialize(lt.value) }; }],
-	[is.LessThanEqual, function(lt, serialize){ return {$lte: serialize(lt.value) }; }],
-	[is.And, function(and, serialize){
+	[is.GreaterThan, function(gt, serialize) { return {$gt: serialize(gt.value) }; }],
+	[is.GreaterThanEqual, function(gte, serialize) { return {$gte: serialize(gte.value) }; }],
+	[is.LessThan, function(lt, serialize) { return {$lt: serialize(lt.value) }; }],
+	[is.LessThanEqual, function(lt, serialize) { return {$lte: serialize(lt.value) }; }],
+	[is.And, function(and, serialize) {
 		var obj = {};
-		and.values.forEach(function(clause){
+		and.values.forEach(function(clause) {
 			canReflect.assignMap(obj, serialize(clause) );
 		});
 		return obj;
 	}],
-	[is.All, function(all, serialize) { return {$all: serialize(all.values)}}]
-	/*[is.Or, function(or, serialize){
+	[is.All, function(all, serialize) {
 		return {
-			$or: or.values.map(function(value){
+			$all: serialize(all.values)
+		};
+	}]
+	/*[is.Or, function(or, serialize) {
+		return {
+			$or: or.values.map(function(value) {
 				return serialize(value, serialize);
 			})
 		};
 	}]*/
 ]);
 
-function hydrateValue(value, hydrateUnknown){
+function hydrateValue(value, hydrateUnknown) {
 	if(!hydrateUnknown) {
-		hydrateUnknown = function(){
+		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 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]
+		var allKeysAreComparisons = keys.every(function(key) {
+			return hydrateMap[key];
 		});
 		if(allKeysAreComparisons) {
-			var andClauses = keys.map(function(key){
+			var andClauses = keys.map(function(key) {
 				var part = {};
 				part[key] = value[key];
 				var hydrator = hydrateMap[key];

src/types/array-comparisons.js

@@ -24,7 +24,7 @@ comparisons.All.test = function(allValues, recordValues) {
 function makeThrowCannotCompare(type, left, right) {
 	return function() {
 		throw new Error("can-query-logic: Cannot perform " + type + " between " + left + " and " + right);
-	}
+	};
 }
 
 function throwComparatorAllTypes(type1, type2) {
@@ -73,7 +73,7 @@ var comparators = {
 	And_All: throwComparatorAllTypes("And",	 "All"),
 	All_Or: throwComparatorDifference("All", "Or"),
 	Or_All: throwComparatorAllTypes("Or", "All")
-}
+};
 
 exports.comparisons = comparisons;
 exports.comparators = comparators;

src/types/basic-query-filter-from-test.js

@@ -124,9 +124,11 @@ QUnit.test("returns undefined against incompatible set", function(assert) {
     var fromQuery = new BasicQuery({
         filter: new BasicQuery.KeysAnd({ type: 'critical' })
     });
+		var res;
 	try{
-		var res = query.filterFrom(items, fromQuery);
+		res = query.filterFrom(items, fromQuery);
 	} catch(e) {
-		assert.ok(true, "throws an error")
+		assert.ok(true, "throws an error");
 	}
+	assert.notOk(res, "did not throw an error");
 });