First rough draft of adding support for promises.

jimlloyd · jimlloyd · commit e79e0a3a2c68 · 2015-01-14T10:46:00.000-08:00
diff --git a/package.json b/package.json
@@ -32,6 +32,7 @@
   },
   "devDependencies": {
     "async": "~0.1.22",
+    "bluebird": "^2.6.0",
     "nodeunit": "0.9.0"
   },
   "scripts": {
diff --git a/src/java.cpp b/src/java.cpp
@@ -79,6 +79,7 @@ NAN_METHOD(Java::New) {
   NanObjectWrapHandle(self)->Set(NanNew<v8::String>("classpath"), NanNew<v8::Array>());
   NanObjectWrapHandle(self)->Set(NanNew<v8::String>("options"), NanNew<v8::Array>());
   NanObjectWrapHandle(self)->Set(NanNew<v8::String>("nativeBindingLocation"), NanNew<v8::String>("Not Set"));
+  NanObjectWrapHandle(self)->Set(NanNew<v8::String>("asyncOptions"), NanNull());
 
   NanReturnValue(args.This());
 }
@@ -104,6 +105,21 @@ v8::Local<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   JavaVM* jvmTemp;
   JavaVMInitArgs args;
 
+  v8::Local<v8::Value> asyncOptions = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("asyncOptions"));
+  if (asyncOptions->IsObject()) {
+    v8::Local<v8::Object> asyncOptionsObj = asyncOptions->ToObject();
+    v8::Local<v8::Value> promisify = asyncOptionsObj->Get(NanNew<v8::String>("promisify"));
+    if (!promisify->IsFunction()) {
+      return NanTypeError("asyncOptions.promisify must be a function");
+    }
+    v8::Local<v8::Value> suffix = asyncOptionsObj->Get(NanNew<v8::String>("suffix"));
+    if (!suffix->IsString()) {
+      return NanTypeError("asyncOptions.suffix must be a string");
+    }
+    v8::Handle<v8::Object> asyncOptionsObjTemp = v8::Handle<v8::Object>::Cast(asyncOptionsObj);
+    NanAssignPersistent(m_asyncOptions, asyncOptionsObjTemp);
+  }
+
   // setup classpath
   std::ostringstream classPath;
   classPath << "-Djava.class.path=";
diff --git a/src/java.h b/src/java.h
@@ -59,6 +59,7 @@ class Java : public node::ObjectWrap {
   static std::string s_nativeBindingLocation;
   v8::Persistent<v8::Array> m_classPathArray;
   v8::Persistent<v8::Array> m_optionsArray;
+  v8::Persistent<v8::Object> m_asyncOptions;
 };
 
 #endif
diff --git a/src/javaObject.cpp b/src/javaObject.cpp
@@ -27,6 +27,19 @@
   std::replace(className.begin(), className.end(), '[', 'a');
   className = "nodeJava_" + className;
 
+  // Set up promisification
+  v8::Local<v8::Object> asyncOptions = NanObjectWrapHandle(java)->Get(NanNew<v8::String>("asyncOptions"))->ToObject();
+  v8::Local<v8::Function> promisify;
+  std::string promiseSuffix;
+  bool promisifying = asyncOptions->IsObject();
+  if(promisifying) {
+    v8::Local<v8::Value> promisifyValue = asyncOptions->Get(NanNew<v8::String>("promisify"));
+    promisify = v8::Function::Cast(*promisifyValue);
+    v8::Local<v8::String> suffix = asyncOptions->Get(NanNew<v8::String>("suffix"))->ToString();
+    v8::String::Utf8Value utf8(suffix);
+    promiseSuffix.assign(*utf8);
+  }
+
   v8::Local<v8::FunctionTemplate> funcTemplate;
   if(sFunctionTemplates.find(className) != sFunctionTemplates.end()) {
     //printf("existing className: %s\n", className.c_str());
@@ -54,6 +67,18 @@
       v8::Handle<v8::String> methodNameSync = NanNew<v8::String>((methodNameStr + "Sync").c_str());
       v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = NanNew<v8::FunctionTemplate>(methodCallSync, methodName);
       funcTemplate->PrototypeTemplate()->Set(methodNameSync, methodCallSyncTemplate->GetFunction());
+
+      if (promisifying) {
+        v8::Local<v8::Object> recv = asyncOptions; // just a dummy receiver
+        v8::Local<v8::Value> argv[] = { methodCallTemplate->GetFunction() };
+        v8::Local<v8::Value> result = promisify->Call(recv, 1, argv);
+        if (!result->IsFunction()) {
+          printf("Promisified result is not a function.\n");
+        }
+        v8::Local<v8::Function> promFunction = v8::Function::Cast(*result);
+        v8::Handle<v8::String> methodNamePromise = NanNew<v8::String>((methodNameStr + promiseSuffix).c_str());\
+        funcTemplate->PrototypeTemplate()->Set(methodNamePromise, promFunction);
+      }
     }
 
     std::list<jobject> fields;
diff --git a/test/promises-test.js b/test/promises-test.js
@@ -0,0 +1,31 @@
+var java = require("../testHelpers").java;
+
+var nodeunit = require("nodeunit");
+var util = require("util");
+
+exports['Promises'] = nodeunit.testCase({
+  "create an instance of a class and call methods (getClassPromise & getNamePromise)": function(test) {
+    java.newInstance("java.util.ArrayList", function(err, list) {
+      if (err) {
+        console.log(err);
+        return;
+      }
+      test.ok(list);
+      if (list) {
+        list.getClassPromise()
+          .then(function(clazz) { return clazz.getNamePromise(); })
+          .then(function(name) {
+            test.equal(name, "java.util.ArrayList");
+          })
+          .catch(function(err) {
+            test.ifError(err);
+          })
+          .then(function() {
+            test.expect(2);
+            test.done();
+          })
+      }
+    });
+  },
+});
+
diff --git a/testHelpers.js b/testHelpers.js
@@ -7,4 +7,9 @@ java.classpath.push("test/");
 java.classpath.push("test/commons-lang3-3.1.jar");
 java.classpath.push("test8/");
 
+java.asyncOptions = {
+  suffix: 'Promise',
+  promisify: require('bluebird').promisify
+};
+
 module.exports.java = java;
