Refactor with ES6 standard

Author: jbienkowski311

lib/zk_promise.js

@@ -1,48 +1,90 @@
-const promise = require("./promise");
-const ZooKeeper = require ("./zookeeper");
+const ZooKeeper = require("./zookeeper");
 
-class ZooKeeperPromise extends ZooKeeper {}
+class ZooKeeperPromise extends ZooKeeper {
+  on_connected() {
+    return new Promise((resolve) => {
+      this.once('connect', () => {
+        return resolve(this);
+      });
+    })
+  }
 
-exports = module.exports = ZooKeeperPromise;
-exports.ZK = ZooKeeperPromise; // backwards compatibility
+  create() {
+    return this._promisify(super.a_create, arguments);
+  }
+
+  exists() {
+    return this._promisify(super.a_exists, arguments);
+  }
+
+  w_exists() {
+    return this._promisify(super.aw_exists, arguments);
+  }
+
+  get() {
+    return this._promisify(super.a_get, arguments);
+  }
+
+  w_get() {
+    return this._promisify(super.aw_get, arguments);
+  }
+
+  get_children() {
+    return this._promisify(super.a_get_children, arguments);
+  }
+
+  w_get_children() {
+    return this._promisify(super.aw_get_children, arguments);
+  }
+
+  get_children2() {
+    return this._promisify(super.a_get_children2, arguments);
+  }
 
-ZooKeeperPromise.prototype.on_connected = function on_connected() {
-  var deferred = promise.defer();
-  this.once ('connect', () => {
-    deferred.resolve(this);
-  });
-  return deferred.promise;
-};
-
-const convertAsync = (fn) => {
-  return () => {
-    var deferred = promise.defer();
-    arguments.length++;
-    arguments[arguments.length-1] = (rc, error, result) => {
-      if (rc) {
-        deferred.emitError(rc);
-      } else {
-        if (arguments.length > 3) {
-          // if there are multiple success values, we return an array
-          Array.prototype.shift.call(arguments, 1);
-          Array.prototype.shift.call(arguments, 1);
-          deferred.emitSuccess(arguments);
+  w_get_children2() {
+    return this._promisify(super.aw_get_children2, arguments);
+  }
+
+  set() {
+    return this._promisify(super.a_set, arguments);
+  }
+
+  delete_() {
+    return this._promisify(super.delete_, arguments);
+  }
+
+  get_acl() {
+    return this._promisify(super.a_get_acl, arguments);
+  }
+
+  set_acl() {
+    return this._promisify(super.a_set_acl, arguments);
+  }
+
+  sync() {
+    return this._promisify(super.a_sync, arguments);
+  }
+
+  _promisify(fn, args) {
+    return new Promise((resolve, reject) => {
+      const callback = (rc, error, result) => {
+        if (rc) {
+          reject(rc);
         } else {
-          deferred.emitSuccess(result);
+          if (args.length > 3) {
+            // if there are multiple success values, we return an array
+            Array.prototype.shift.call(args, 1);
+            Array.prototype.shift.call(args, 1);
+            resolve(args);
+          } else {
+            resolve(result);
+          }
         }
-      }
-    };
-    fn.apply(this, arguments);
-    return deferred.promise;
-  };
-};
-
-for (var f in ZooKeeperPromise.prototype) {
-    var m = f.match(/^a(w?)_(.*)$/);
-    if (m) {
-        var new_func = m[1]? m[1] + "_" + m[2] : m[2];
-        ZooKeeperPromise.prototype[new_func] = convertAsync (ZooKeeperPromise.prototype[f]);
-        //console.log ("function %s is %j", f, util.inspect(ZK.prototype[new_func],true,3));
-    }
+      };
+      fn.apply(this, [...args, callback])
+    });
+  }
 }
 
+exports = module.exports = ZooKeeperPromise;
+exports.ZK = ZooKeeperPromise; // backwards compatibility