Merge pull request #41 from canjs/fix-biscting-when-compare-0

fix in helper.index

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");

src/helpers-test.js

@@ -0,0 +1,87 @@
+var QUnit = require("steal-qunit");
+var helpers = require("./helpers");
+var canReflect = require("can-reflect");
+
+QUnit.module("can-query-logic/helpers");
+
+
+QUnit.test('.getIdentityIndex', function(){
+	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);
+	QUnit.deepEqual(res, 1);
+});
+
+QUnit.test(".getIndex should not sort unchanged items #33", function() {
+	
+	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]);
+	
+	
+	QUnit.equal(res1, 0);
+	QUnit.equal(res2, 1);
+	QUnit.equal(res3, 2);
+	QUnit.equal(res4, 3);
+});

src/helpers.js

@@ -49,6 +49,56 @@ 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) {
+		var identity = canReflect.getIdentity(props),
+			starterItem = items[startIndex];
+		// check if the middle has a match
+		if (compare(props, starterItem) === 0) {
+			if (identity === canReflect.getIdentity(starterItem)) {
+				return startIndex;
+			}
+		}
+		
+		var rightResult = this.getIdentityIndexByDirection(compare, items, props, startIndex+1, 1),
+			leftResult;
+		if(rightResult.index) {
+			return rightResult.index;
+		} else {
+			leftResult = this.getIdentityIndexByDirection(compare, items, props, startIndex-1, -1);
+		}
+		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) {
+		var currentIndex = startIndex;
+		var identity = canReflect.getIdentity(props);
+		while(currentIndex >= 0 && currentIndex < items.length) {
+			var currentItem = items[currentIndex];
+			var computed = compare(props, currentItem);
+			if(computed === 0) {
+				if( identity === canReflect.getIdentity(currentItem)) {
+					return {index: currentIndex};
+				}
+			} else {
+				return {lastIndex: currentIndex - direction};
+			}
+			currentIndex = currentIndex + direction;
+		}
+		return {lastIndex: currentIndex - direction};
+	},
 	//
 	getIndex: function(compare, items, props) {
 		if (!items || !items.length) {
@@ -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);
 			} 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/types/basic-query-sorting-test.js

@@ -356,52 +356,3 @@ QUnit.test("index uses can-reflect", function(){
     QUnit.deepEqual([obj1Read, obj2Read, itemKeyRead, itemOwnKeyRead],
         [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
-					}
-				};
-			}
-		});
-	});
-
-
-
-	var query = new BasicQuery({
-        sort: "name"
-	});
-	
-	var res = query.index({id:4, name: "Item 1"}, items);
-
-	QUnit.equal(res, 3);
-});