refactor: use maybePromise instead of fake operations

lib/cursor.js

@@ -9,16 +9,12 @@ const MongoError = require('./core').MongoError;
 const CoreCursor = require('./core/cursor').CoreCursor;
 const CursorState = require('./core/cursor').CursorState;
 const Map = require('./core').BSON.Map;
+const maybePromise = require('./utils').maybePromise;
+const executeOperation = require('./operations/execute_operation');
 
 const each = require('./operations/cursor_ops').each;
-
 const CountOperation = require('./operations/count');
-const ExplainOperation = require('./operations/explain');
-const HasNextOperation = require('./operations/has_next');
-const NextOperation = require('./operations/next');
-const ToArrayOperation = require('./operations/to_array');
-
-const executeOperation = require('./operations/execute_operation');
+const nextObject = require('./operations/common_functions').nextObject;
 
 /**
  * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
@@ -199,9 +195,25 @@ class Cursor extends CoreCursor {
    * @return {Promise} returns Promise if no callback passed
    */
   hasNext(callback) {
-    const hasNextOperation = new HasNextOperation(this);
+    return maybePromise(callback, cb => {
+      const cursor = this;
+      if (cursor.s.currentDoc) {
+        return cb(null, true);
+      }
+
+      if (cursor.isNotified()) {
+        return cb(null, false);
+      }
 
-    return executeOperation(this.topology, hasNextOperation, callback);
+      nextObject(cursor, (err, doc) => {
+        if (err) return cb(err);
+        if (cursor.s.state === Cursor.CLOSED || cursor.isDead()) return cb(null, false);
+        if (!doc) return cb(null, false);
+
+        cursor.s.currentDoc = doc;
+        cb(null, true);
+      });
+    });
   }
 
   /**
@@ -212,9 +224,19 @@ class Cursor extends CoreCursor {
    * @return {Promise} returns Promise if no callback passed
    */
   next(callback) {
-    const nextOperation = new NextOperation(this);
+    return maybePromise(callback, cb => {
+      const cursor = this;
+
+      // Return the currentDoc if someone called hasNext first
+      if (cursor.s.currentDoc) {
+        const doc = cursor.s.currentDoc;
+        cursor.s.currentDoc = null;
+        return cb(null, doc);
+      }
 
-    return executeOperation(this.topology, nextOperation, callback);
+      // Return the next object
+      nextObject(cursor, cb);
+    });
   }
 
   /**
@@ -784,9 +806,49 @@ class Cursor extends CoreCursor {
       });
     }
 
-    const toArrayOperation = new ToArrayOperation(this);
+    return maybePromise(callback, cb => {
+      const cursor = this;
+      const items = [];
 
-    return executeOperation(this.topology, toArrayOperation, callback);
+      // Reset cursor
+      cursor.rewind();
+      cursor.s.state = CursorState.INIT;
+
+      // Fetch all the documents
+      const fetchDocs = () => {
+        cursor._next((err, doc) => {
+          if (err) {
+            return cursor._endSession
+              ? cursor._endSession(() => handleCallback(cb, err))
+              : handleCallback(cb, err);
+          }
+
+          if (doc == null) {
+            return cursor.close({ skipKillCursors: true }, () => handleCallback(cb, null, items));
+          }
+
+          // Add doc to items
+          items.push(doc);
+
+          // Get all buffered objects
+          if (cursor.bufferedCount() > 0) {
+            let docs = cursor.readBufferedDocuments(cursor.bufferedCount());
+
+            // Transform the doc if transform method added
+            if (cursor.s.transforms && typeof cursor.s.transforms.doc === 'function') {
+              docs = docs.map(cursor.s.transforms.doc);
+            }
+
+            Array.prototype.push.apply(items, docs);
+          }
+
+          // Attempt a fetch
+          fetchDocs();
+        });
+      };
+
+      fetchDocs();
+    });
   }
 
   /**
@@ -972,9 +1034,9 @@ class Cursor extends CoreCursor {
       delete this.cmd['readConcern'];
     }
 
-    const explainOperation = new ExplainOperation(this);
-
-    return executeOperation(this.topology, explainOperation, callback);
+    return maybePromise(callback, cb => {
+      CoreCursor.prototype._next.apply(this, [cb]);
+    });
   }
 
   /**