Fix tests

Author: cherifGsoul

can-query-logic-test.js

@@ -1,4 +1,5 @@
 require("./src/set-test");
+require("./src/helpers-test");
 require("./src/types/make-real-number-range-inclusive-test");
 require("./src/types/comparisons-test");
 require("./src/types/and-or-not-test");

doc/can-query-logic.md

@@ -4,6 +4,7 @@
 @group can-query-logic.prototype 1 prototype
 @group can-query-logic/query-format 2 query format
 @group can-query-logic.static 3 static methods
+@package ../package.json
 
 @group can-query-logic.static-types 4 static types
 @outline 3

package.json

@@ -1,6 +1,6 @@
 {
   "name": "can-query-logic",
-  "version": "1.1.10",
+  "version": "1.1.13",
   "description": "query data",
   "homepage": "",
   "repository": {

src/helpers-test.js

@@ -0,0 +1,102 @@
+var QUnit = require("steal-qunit");
+var helpers = require("./helpers");
+var canReflect = require("can-reflect");
+
+QUnit.module("can-query-logic/helpers");
+
+
+QUnit.test('.getIdentityIndex', function(assert){
+	var items = [
+		{id: 1, name: "Item 0"},
+		{id: 2, name: "Item 1"},
+		{id: 3, name: "Item 1"},
+		{id: 4, name: "Item 1"},
+		{id: 5, name: "Item 2"}
+	];
+
+	canReflect.eachIndex(items, function(item) {
+		canReflect.assignSymbols(item, {
+			"can.getSchema": function() {
+				return {
+					type: "map",
+					identity: ["id"],
+					keys: {
+						id: Number,
+						name: String
+					}
+				};
+			}
+		});
+	});
+
+	var props = {id:2, name: "Item 1"};
+	canReflect.assignSymbols(props,{
+		"can.getSchema": function() {
+			return {
+				type: "map",
+				identity: ["id"],
+				keys: {
+					id: Number,
+					name: String
+				}
+			};
+		}
+	});
+	var compare = helpers.sorter("name", {});
+	var res = helpers.getIdentityIndex(compare, items, props, 1);
+	assert.deepEqual(res, 1);
+});
+
+QUnit.test(".getIndex should not sort unchanged items #33", function(assert) {
+	
+	var items = [
+		{id: 1, name: "Item 0"},
+		{id: 2, name: "Item 1"},
+		{id: 3, name: "Item 1"},
+		{id: 4, name: "Item 1"},
+		{id: 5, name: "Item 2"}
+	];
+
+	canReflect.eachIndex(items, function(item) {
+		canReflect.assignSymbols(item, {
+			"can.getSchema": function() {
+				return {
+					type: "map",
+					identity: ["id"],
+					keys: {
+						id: Number,
+						name: String
+					}
+				};
+			}
+		});
+	});
+
+	var compare = helpers.sorter("name", {});
+
+	var res1 = helpers.getIndex(compare,items, items[0]);
+	var res2 = helpers.getIndex(compare,items, items[1]);
+	var res3 = helpers.getIndex(compare,items, items[2]);
+	var res4 = helpers.getIndex(compare,items, items[3]);
+	
+	
+	assert.equal(res1, 0);
+	assert.equal(res2, 1);
+	assert.equal(res3, 2);
+	assert.equal(res4, 3);
+});
+
+QUnit.test("Missed schema on helper.getIndex #45", function(assert) {
+	var items = [
+		{id: 1, name: "Item 0"},
+		{id: 2, name: "Item 1"},
+		{id: 3, name: "Item 2"},
+		{id: 4, name: "Item 3"},
+		{id: 5, name: "Item 4"}
+	];
+	
+	var compare = helpers.sorter("name", {});
+	var schema = { keys: {}, identity: ["id"] };
+	
+	assert.equal(helpers.getIndex(compare,items, {id: 2, name: "Item 1"}, schema), 1);
+});

src/helpers.js

@@ -49,8 +49,58 @@ var helpers = {
 			}
 		});
 	},
+	// Get the index of an item by it's identity
+	// Starting from the middle of the items
+	// return the index of match in the right direction
+	// or in the left direction
+	// otherwise return the last index
+	// see getIdentityIndexByDirection
+	getIdentityIndex: function(compare, items, props, startIndex, schema) {
+		var identity = canReflect.getIdentity(props, schema),
+			starterItem = items[startIndex];
+		// check if the middle has a match
+		if (compare(props, starterItem) === 0) {
+			if (identity === canReflect.getIdentity(starterItem, schema)) {
+				return startIndex;
+			}
+		}
+		
+		var rightResult = this.getIdentityIndexByDirection(compare, items, props, startIndex+1, 1, schema),
+			leftResult;
+		if(rightResult.index) {
+			return rightResult.index;
+		} else {
+			leftResult = this.getIdentityIndexByDirection(compare, items, props, startIndex-1, -1, schema);
+		}
+		if(leftResult.index !== undefined) {
+			return leftResult.index;
+		}
+		// put at the last index item that doesn't match an identity
+		return rightResult.lastIndex;
+	},
+	// Get the index of an item by it's identity
+	// for a given direction (right or left)
+	// 1 for right
+	// -1 for left
+	getIdentityIndexByDirection: function(compare, items, props, startIndex, direction, schema) {
+		var currentIndex = startIndex;
+		var identity = canReflect.getIdentity(props, schema);
+		while(currentIndex >= 0 && currentIndex < items.length) {
+			var currentItem = items[currentIndex];
+			var computed = compare(props, currentItem);
+			if(computed === 0) {
+				if( identity === canReflect.getIdentity(currentItem, schema)) {
+					return {index: currentIndex};
+				}
+			} else {
+				return {lastIndex: currentIndex - direction};
+			}
+			currentIndex = currentIndex + direction;
+		}
+		return {lastIndex: currentIndex - direction};
+	},
 	//
-	getIndex: function(compare, items, props) {
+	getIndex: function(compare, items, props, schema) {
 		if (!items || !items.length) {
 			return undefined;
 		}
@@ -62,35 +112,22 @@ var helpers = {
 		}
 
 		var low = 0,
-			high = items.length,
-			range = [];
+			high = items.length;
 
 		// From lodash lodash 4.6.1 <https://lodash.com/>
 		// Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
 		while (low < high) {
 			var mid = (low + high) >>> 1,
 				item = items[mid],
 				computed = compare(props, item);
-			
 			if (computed === 0) {
-				range.push(item);
-				low++;
+				return this.getIdentityIndex(compare, items, props, mid, schema);
 			} else if (computed === -1) {
 				high = mid;
 			} else {
 				low = mid + 1;
 			}
 		}
-		if (range.length > 0) {
-			for (var i = 0; i < range.length; i++) {
-				var itemInRange = range[i],
-					id = canReflect.getSchema(itemInRange).identity[0];
-				if (canReflect.hasOwnKey(props, id) && props[id] === itemInRange[id]) {
-					high = items.indexOf(itemInRange);
-					break;
-				}	
-			}
-		}
 		return high;
 		// bisect by calling sortFunc
 	},

src/serializers/basic-query.js

@@ -281,7 +281,7 @@ module.exports = function(schema) {
 
 
 	// Makes a sort type that can make a compare function using the SetType
-	var Sort = BasicQuery.makeSort(keys, hydrateAndValue);
+	var Sort = BasicQuery.makeSort(schema, hydrateAndValue);
 	var serializer = new Serializer(serializeMap);
 	serializer.add(comparisonsConverter.serializer);
 

src/types/basic-query-sorting-test.js

@@ -357,51 +357,13 @@ QUnit.test("index uses can-reflect", function(assert) {
         [true, true, true, true], "read everything");
 });
 
-
-QUnit.test("index should not sort unchanged items #33", function(assert) {
-	canReflect.assignSymbols({},{
-		"can.getSchema": function() {
-			return {
-				type: "map",
-				identity: ["id"],
-				keys: {
-					id: Number,
-					name: String
-				}
-			};
-		}
-	});
-	
-	var items = [
-		{id: 1, name: "Item 0"},
-		{id: 2, name: "Item 1"},
-		{id: 3, name: "Item 1"},
-		{id: 4, name: "Item 1"},
-		{id: 5, name: "Item 2"}
-	];
-
-	canReflect.eachIndex(items, function(item, i) {
-		canReflect.assignSymbols(item, {
-			"can.getSchema": function() {
-				return {
-					type: "map",
-					identity: ["id"],
-					keys: {
-						id: Number,
-						name: String
-					}
-				};
-			}
-		});
-	});
-
-
-
+QUnit.test(".index should work with literal objects", function(assert) {
 	var query = new BasicQuery({
-        sort: "name"
+		sort: "name"
 	});
-	
-	var res = query.index({id:4, name: "Item 1"}, items);
 
-	assert.equal(res, 3);
+	var items = [{id: 1, name: "Item 0"}, {id: 2, name: "Item 1"}];
+	var res = query.index({id: 1, name: "Item 1"}, items);
+
+	assert.equal(res, 1, "Item index at 1");
 });

src/types/basic-query.js

@@ -37,7 +37,8 @@ var RecordRange = makeRealNumberRangeInclusive(0, Infinity);
 // That compare function will read the right property and return `-1` or `1`
 
 // WILL MAKE A TYPE FOR SORTING
-function makeSort(schemaKeys, hydrateAndValue) {
+function makeSort(schema, hydrateAndValue) {
+	var schemaKeys = schema.keys;
 	// Makes gt and lt functions that `helpers.sorter` can use
 	// to make a `compare` function for `Array.sort(compare)`.`
 	var sorters = {};
@@ -107,6 +108,7 @@ function makeSort(schemaKeys, hydrateAndValue) {
 
 	function Sort(key) {
 		this.key = key;
+		this.schema = schema;
 		this.compare = helpers.sorter(key, sorters);
 	}
 
@@ -129,7 +131,7 @@ function makeSort(schemaKeys, hydrateAndValue) {
 	return Sort;
 }
 
-var DefaultSort = makeSort({});
+var DefaultSort = makeSort({ keys: {}, identity: ["id"] });
 
 
 // Define the BasicQuery type
@@ -234,7 +236,7 @@ canReflect.assignMap(BasicQuery.prototype, {
 			return undefined;
 		}
 		// use the passed sort's compare function
-		return helpers.getIndex(this.sort.compare, items, props);
+		return helpers.getIndex(this.sort.compare, items, props, this.sort.schema);
 	},
 	isMember: function(props) {
 		// Use the AND type for it's isMember method