Separate out CachedSyncIterable and CachedAsyncIterable.

Copy of projectfluent/fluent.js@b44b802.

README.md

@@ -1,7 +1,10 @@
 # cached-iterable
 
-`cached-iterable` exposes the `CachedItearble` class which implements the
-[iterable protocol][].
+`cached-iterable` exposes two classes which implement the [iterable
+protocol][]:
+
+  - `CachedSyncIterable`,
+  - `CachedAsyncIterable`.
 
 You can wrap any iterable in these classes to create a new iterable which
 caches the yielded elements. This is useful for iterating over an iterable many
@@ -21,15 +24,15 @@ can install it from the npm registry or use it as a standalone script (as the
 
 ```js
 import assert from "assert";
-import {CachedIterable} from "cached-iterable";
+import {CachedSyncIterable} from "cached-iterable";
 
 function * countdown(i) {
     while (i--) {
         yield i;
     }
 }
 
-let numbers = new CachedIterable(countdown(3));
+let numbers = new CachedSyncIterable(countdown(3));
 
 // `numbers` can be iterated over multiple times.
 assert.deepEqual([...numbers], [3, 2, 1, 0]);
@@ -42,7 +45,7 @@ For legacy browsers, the `compat` build has been transpiled using Babel's [env
 preset][]. It requires the regenerator runtime provided by [babel-polyfill][].
 
 ```javascript
-import {CachedIterable} from 'cached-iterable/compat';
+import {CachedSyncIterable} from 'cached-iterable/compat';
 ```
 
 [env preset]: https://babeljs.io/docs/plugins/preset-env/

src/cached_iterable.mjs → src/cached_async_iterable.mjs

@@ -1,15 +1,15 @@
 /*
- * CachedIterable caches the elements yielded by an iterable.
+ * CachedAsyncIterable caches the elements yielded by an async iterable.
  *
  * It can be used to iterate over an iterable many times without depleting the
  * iterable.
  */
-export default class CachedIterable {
+export default class CachedAsyncIterable {
     /**
-     * Create an `CachedIterable` instance.
+     * Create an `CachedAsyncIterable` instance.
      *
      * @param {Iterable} iterable
-     * @returns {CachedIterable}
+     * @returns {CachedAsyncIterable}
      */
     constructor(iterable) {
         if (Symbol.asyncIterator in Object(iterable)) {
@@ -23,20 +23,6 @@ export default class CachedIterable {
         this.seen = [];
     }
 
-    [Symbol.iterator]() {
-        const { seen, iterator } = this;
-        let cur = 0;
-
-        return {
-            next() {
-                if (seen.length <= cur) {
-                    seen.push(iterator.next());
-                }
-                return seen[cur++];
-            }
-        };
-    }
-
     [Symbol.asyncIterator]() {
         const { seen, iterator } = this;
         let cur = 0;
@@ -54,11 +40,16 @@ export default class CachedIterable {
     /**
      * This method allows user to consume the next element from the iterator
      * into the cache.
+     *
+     * @param {number} count - number of elements to consume
      */
-    touchNext() {
+    async touchNext(count = 1) {
         const { seen, iterator } = this;
-        if (seen.length === 0 || seen[seen.length - 1].done === false) {
-            seen.push(iterator.next());
+        let idx = 0;
+        while (idx++ < count) {
+            if (seen.length === 0 || seen[seen.length - 1].done === false) {
+                seen.push(await iterator.next());
+            }
         }
     }
 }

src/cached_sync_iterable.mjs

@@ -0,0 +1,53 @@
+/*
+ * CachedSyncIterable caches the elements yielded by an iterable.
+ *
+ * It can be used to iterate over an iterable many times without depleting the
+ * iterable.
+ */
+export default class CachedSyncIterable {
+    /**
+     * Create an `CachedSyncIterable` instance.
+     *
+     * @param {Iterable} iterable
+     * @returns {CachedSyncIterable}
+     */
+    constructor(iterable) {
+        if (Symbol.iterator in Object(iterable)) {
+            this.iterator = iterable[Symbol.iterator]();
+        } else {
+            throw new TypeError("Argument must implement the iteration protocol.");
+        }
+
+        this.seen = [];
+    }
+
+    [Symbol.iterator]() {
+        const { seen, iterator } = this;
+        let cur = 0;
+
+        return {
+            next() {
+                if (seen.length <= cur) {
+                    seen.push(iterator.next());
+                }
+                return seen[cur++];
+            }
+        };
+    }
+
+    /**
+     * This method allows user to consume the next element from the iterator
+     * into the cache.
+     *
+     * @param {number} count - number of elements to consume
+     */
+    touchNext(count = 1) {
+        const { seen, iterator } = this;
+        let idx = 0;
+        while (idx++ < count) {
+            if (seen.length === 0 || seen[seen.length - 1].done === false) {
+                seen.push(iterator.next());
+            }
+        }
+    }
+}

src/index.mjs

@@ -1 +1,2 @@
-export {default as CachedIterable} from "./cached_iterable.mjs";
+export {default as CachedSyncIterable} from "./cached_sync_iterable.mjs";
+export {default as CachedAsyncIterable} from "./cached_async_iterable.mjs";

test/cached_async_iterable_test.js

@@ -0,0 +1,176 @@
+import assert from "assert";
+import {CachedAsyncIterable} from "../src/index";
+
+/**
+ * Return a promise for an array with all the elements of the iterable.
+ *
+ * It uses for-await to support async iterables which can't be spread with
+ * ...iterable. See https://github.com/tc39/proposal-async-iteration/issues/103
+ *
+ */
+async function toArray(iterable) {
+    const result = [];
+    for await (const elem of iterable) {
+        result.push(elem);
+    }
+    return result;
+}
+
+suite("CachedAsyncIterable", function() {
+    suite("constructor errors", function(){
+        test("no argument", function() {
+            function run() {
+                new CachedAsyncIterable();
+            }
+
+            assert.throws(run, TypeError);
+            assert.throws(run, /iteration protocol/);
+        });
+
+        test("null argument", function() {
+            function run() {
+                new CachedAsyncIterable(null);
+            }
+
+            assert.throws(run, TypeError);
+            assert.throws(run, /iteration protocol/);
+        });
+
+        test("bool argument", function() {
+            function run() {
+                new CachedAsyncIterable(1);
+            }
+
+            assert.throws(run, TypeError);
+            assert.throws(run, /iteration protocol/);
+        });
+
+        test("number argument", function() {
+            function run() {
+                new CachedAsyncIterable(1);
+            }
+
+            assert.throws(run, TypeError);
+            assert.throws(run, /iteration protocol/);
+        });
+    });
+
+    suite("async iteration", function(){
+        let o1, o2;
+
+        suiteSetup(function() {
+            o1 = Object();
+            o2 = Object();
+        });
+
+        test("lazy iterable", async function() {
+            async function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            assert.deepEqual(await toArray(iterable), [o1, o2]);
+        });
+
+        test("lazy iterable works more than once", async function() {
+            async function *generate() {
+                let i = 2;
+
+                while (--i) {
+                    yield Object();
+                }
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            const first = await toArray(iterable);
+            assert.deepEqual(await toArray(iterable), first);
+        });
+    });
+
+    suite("async touchNext", function(){
+        let o1, o2, generateMessages;
+
+        suiteSetup(function() {
+            o1 = Object();
+            o2 = Object();
+
+            generateMessages = async function *generateMessages() {
+                yield *[o1, o2];
+            }
+        });
+
+        test("consumes an element into the cache", async function() {
+            const iterable = new CachedAsyncIterable(generateMessages());
+            assert.equal(iterable.seen.length, 0);
+            await iterable.touchNext();
+            assert.equal(iterable.seen.length, 1);
+        });
+
+        test("allows to consume multiple elements into the cache", async function() {
+            const iterable = new CachedAsyncIterable(generateMessages());
+            await iterable.touchNext();
+            await iterable.touchNext();
+            assert.equal(iterable.seen.length, 2);
+        });
+
+        test("allows to consume multiple elements at once", async function() {
+            const iterable = new CachedAsyncIterable(generateMessages());
+            await iterable.touchNext(2);
+            assert.equal(iterable.seen.length, 2);
+        });
+
+        test("stops at the last element", async function() {
+            const iterable = new CachedAsyncIterable(generateMessages());
+            await iterable.touchNext();
+            await iterable.touchNext();
+            await iterable.touchNext();
+            assert.equal(iterable.seen.length, 3);
+
+            await iterable.touchNext();
+            assert.equal(iterable.seen.length, 3);
+        });
+
+        test("works on an empty iterable", async function() {
+            async function *generateEmptyMessages() {
+                yield *[];
+            }
+            const iterable = new CachedAsyncIterable(generateEmptyMessages());
+            await iterable.touchNext();
+            await iterable.touchNext();
+            await iterable.touchNext();
+            assert.equal(iterable.seen.length, 1);
+        });
+
+        test("iteration for such cache works", async function() {
+            const iterable = new CachedAsyncIterable(generateMessages());
+            await iterable.touchNext();
+            await iterable.touchNext();
+            await iterable.touchNext();
+
+            // It's a bit quirky compared to the sync counterpart,
+            // but there's no good way to fold async iterator into
+            // an array.
+            let values = [];
+            for await (let elem of iterable) {
+                values.push(elem);
+            }
+            assert.deepEqual(values, [o1, o2]);
+        });
+
+        test("async version handles sync iterator", async function() {
+            const iterable = new CachedAsyncIterable([o1, o2]);
+            await iterable.touchNext();
+            await iterable.touchNext();
+            await iterable.touchNext();
+
+            // It's a bit quirky compared to the sync counterpart,
+            // but there's no good way to fold async iterator into
+            // an array.
+            let values = [];
+            for await (let elem of iterable) {
+                values.push(elem);
+            }
+            assert.deepEqual(values, [o1, o2]);
+        });
+    });
+});