Merge pull request #1039 from kalman/null

JS: Correctly check for null key in ordered sequences.

js/src/assert.js

@@ -5,6 +5,10 @@ export function invariant(exp: any, message: string = 'Invariant violated') {
   if (!exp) throw new Error(message);
 }
 
+export function isNullOrUndefined<T>(v: ?T): boolean {
+  return v === null || v === undefined;
+}
+
 export function notNull<T>(v: ?T): T {
   invariant(v !== null && v !== undefined, 'Unexpected null value');
   return v;

js/src/map_test.js

@@ -147,13 +147,13 @@ suite('MapLeaf', () => {
 
     const test = async entries => {
       const m = new NomsMap(tr, new MapLeafSequence(ms, tr, entries));
-      assert.deepEqual(entries, flatten(m.iterator()));
-      assert.deepEqual(entries, flattenParallel(m.iterator(), entries.length));
+      assert.deepEqual(entries, await flatten(m.iterator()));
+      assert.deepEqual(entries, await flattenParallel(m.iterator(), entries.length));
     };
 
-    test([]);
-    test([{key: 'a', value: 4}]);
-    test([{key: 'a', value: 4}, {key: 'k', value: 8}]);
+    await test([]);
+    await test([{key: 'a', value: 4}]);
+    await test([{key: 'a', value: 4}, {key: 'k', value: 8}]);
   });
 
   test('iteratorAt', async () => {

js/src/noms.js

@@ -9,7 +9,7 @@ export {default as MemoryStore} from './memory_store.js';
 export {default as Ref} from './ref.js';
 export {default as Struct} from './struct.js';
 export {encodeNomsValue, writeValue} from './encode.js';
-export {invariant, notNull} from './assert.js';
+export {invariant, isNullOrUndefined, notNull} from './assert.js';
 export {isPrimitiveKind, Kind, kindToString} from './noms_kind.js';
 export {lookupPackage, Package, readPackage, registerPackage} from './package.js';
 export {newList, ListLeafSequence, NomsList} from './list.js';

js/src/ordered_sequence.js

@@ -2,7 +2,7 @@
 
 import {AsyncIterator, AsyncIteratorResult} from './async_iterator.js';
 import type {valueOrPrimitive} from './value.js'; // eslint-disable-line no-unused-vars
-import {invariant, notNull} from './assert.js';
+import {invariant, isNullOrUndefined, notNull} from './assert.js';
 import {less} from './value.js';
 import {search, Sequence, SequenceCursor} from './sequence.js';
 
@@ -20,7 +20,7 @@ export class OrderedSequence<K: valueOrPrimitive, T> extends Sequence<T> {
 
     while (sequence) {
       cursor = new OrderedSequenceCursor(cursor, sequence, last ? -1 : 0);
-      if (key) {
+      if (!isNullOrUndefined(key)) {
         const lastPositionIfNotfound = forInsertion && sequence.isMeta;
         if (!cursor._seekTo(key, lastPositionIfNotfound)) {
           return cursor; // invalid

js/src/set_test.js

@@ -367,4 +367,20 @@ suite('CompoundSet', () => {
     await testIntersect([], [['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
         ['d', 'e', 'f', 'g', 'h', 'i', 'j', 'k'], ['i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']]);
   });
+
+  test('iterator at 0', async () => {
+    const ms = new MemoryStore();
+    const tr = makeCompoundType(Kind.Set, makePrimitiveType(Kind.Int8));
+
+    const test = async (expected, items) => {
+      const set = new NomsSet(tr, new SetLeafSequence(ms, tr, items));
+      const iter = set.iteratorAt(0);
+      assert.deepEqual(expected, await flatten(iter));
+    };
+
+    await test([1, 2], [1, 2]);
+    await test([0, 1, 2], [0, 1, 2]);
+    await test([1, 2], [-2, -1, 1, 2]);
+    await test([0, 1, 2], [-2, -1, 0, 1, 2]);
+  });
 });