Merge pull request #254 from joeferner/upgrade-nan

upgrade nan to 2.0.9

Author: joeferner

.travis.yml

@@ -1,4 +1,5 @@
 language: java
+sudo: false
 jdk:
   - oraclejdk8
   - oraclejdk7

lib/nodeJavaBridge.js

@@ -190,6 +190,8 @@ function isWritable(prop) {
   // (e.g. for either .caller or .arguments).
   // It may be that checking desc.configurable is sufficient, but the specification doesn't make this definitive,
   // and there is no harm in checking both.
+  if (prop === 'caller' || prop === 'arguments') { return false; }
+  
   var desc = Object.getOwnPropertyDescriptor(function() {}, prop) || {};
   return desc.writable !== false &&  desc.configurable !== false;
 }

package.json

@@ -30,7 +30,7 @@
     "find-java-home": "0.1.2",
     "glob": "5.0.5",
     "lodash": "3.7.0",
-    "nan": "1.7.0"
+    "nan": "2.0.9"
   },
   "devDependencies": {
     "chalk": "1.0.0",

src/java.cpp

@@ -14,7 +14,7 @@
 #define JNI_BEST_VERSION JNI_VERSION_1_6
 #endif
 
-class Java : public node::ObjectWrap {
+class Java : public Nan::ObjectWrap {
 public:
   static void Init(v8::Handle<v8::Object> target);
   JavaVM* getJvm() { return m_jvm; }
@@ -60,15 +60,15 @@ class Java : public node::ObjectWrap {
   static NAN_SETTER(AccessorProhibitsOverwritingSetter);
   v8::Local<v8::Value> ensureJvm();
 
-  static v8::Persistent<v8::FunctionTemplate> s_ct;
+  static Nan::Persistent<v8::FunctionTemplate> s_ct;
   JavaVM* m_jvm;
   JNIEnv* m_env; // can only be used safely by the main thread as this is the thread it belongs to
   jobject m_classLoader;
   std::string m_classPath;
   static std::string s_nativeBindingLocation;
-  v8::Persistent<v8::Array> m_classPathArray;
-  v8::Persistent<v8::Array> m_optionsArray;
-  v8::Persistent<v8::Object> m_asyncOptions;
+  Nan::Persistent<v8::Array> m_classPathArray;
+  Nan::Persistent<v8::Array> m_optionsArray;
+  Nan::Persistent<v8::Object> m_asyncOptions;
 
   std::string m_SyncSuffix;
   std::string m_AsyncSuffix;

src/java.h

@@ -5,13 +5,13 @@
 #include <sstream>
 #include <algorithm>
 
-/*static*/ std::map<std::string, v8::Persistent<v8::FunctionTemplate>*> JavaObject::sFunctionTemplates;
+/*static*/ std::map<std::string, Nan::Persistent<v8::FunctionTemplate>*> JavaObject::sFunctionTemplates;
 
 /*static*/ void JavaObject::Init(v8::Handle<v8::Object> target) {
 }
 
 /*static*/ v8::Local<v8::Object> JavaObject::New(Java *java, jobject obj) {
-  NanEscapableScope();
+  Nan::EscapableHandleScope scope;
 
   JNIEnv *env = java->getJavaEnv();
   JavaScope javaScope(env);
@@ -29,21 +29,21 @@
 
   v8::Local<v8::Function> promisify;
   if(java->DoPromise()) {
-    v8::Local<v8::Object> asyncOptions = NanObjectWrapHandle(java)->Get(NanNew<v8::String>("asyncOptions")).As<v8::Object>();
-    v8::Local<v8::Value> promisifyValue = asyncOptions->Get(NanNew<v8::String>("promisify"));
+    v8::Local<v8::Object> asyncOptions = java->handle()->Get(Nan::New<v8::String>("asyncOptions").ToLocalChecked()).As<v8::Object>();
+    v8::Local<v8::Value> promisifyValue = asyncOptions->Get(Nan::New<v8::String>("promisify").ToLocalChecked());
     promisify = promisifyValue.As<v8::Function>();
   }
 
   v8::Local<v8::FunctionTemplate> funcTemplate;
   if(sFunctionTemplates.find(className) != sFunctionTemplates.end()) {
     //printf("existing className: %s\n", className.c_str());
-    funcTemplate = NanNew(*sFunctionTemplates[className]);
+    funcTemplate = Nan::New(*sFunctionTemplates[className]);
   } else {
     //printf("create className: %s\n", className.c_str());
 
-    funcTemplate = NanNew<v8::FunctionTemplate>();
+    funcTemplate = Nan::New<v8::FunctionTemplate>();
     funcTemplate->InstanceTemplate()->SetInternalFieldCount(1);
-    funcTemplate->SetClassName(NanNew<v8::String>(className.c_str()));
+    funcTemplate->SetClassName(Nan::New<v8::String>(className.c_str()).ToLocalChecked());
 
     std::list<jobject> methods;
     javaReflectionGetMethods(env, objClazz, &methods, false);
@@ -54,26 +54,26 @@
       assert(!env->ExceptionCheck());
       std::string methodNameStr = javaToString(env, methodNameJava);
 
-      v8::Handle<v8::String> baseMethodName = NanNew<v8::String>(methodNameStr.c_str());
+      v8::Local<v8::String> baseMethodName = Nan::New<v8::String>(methodNameStr.c_str()).ToLocalChecked();
 
-      v8::Handle<v8::String> methodNameAsync = NanNew<v8::String>((methodNameStr + java->AsyncSuffix()).c_str());
-      v8::Local<v8::FunctionTemplate> methodCallTemplate = NanNew<v8::FunctionTemplate>(methodCall, baseMethodName);
+      v8::Local<v8::String> methodNameAsync = Nan::New<v8::String>((methodNameStr + java->AsyncSuffix()).c_str()).ToLocalChecked();
+      v8::Local<v8::FunctionTemplate> methodCallTemplate = Nan::New<v8::FunctionTemplate>(methodCall, baseMethodName);
       funcTemplate->PrototypeTemplate()->Set(methodNameAsync, methodCallTemplate->GetFunction());
 
-      v8::Handle<v8::String> methodNameSync = NanNew<v8::String>((methodNameStr + java->SyncSuffix()).c_str());
-      v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = NanNew<v8::FunctionTemplate>(methodCallSync, baseMethodName);
+      v8::Local<v8::String> methodNameSync = Nan::New<v8::String>((methodNameStr + java->SyncSuffix()).c_str()).ToLocalChecked();
+      v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = Nan::New<v8::FunctionTemplate>(methodCallSync, baseMethodName);
       funcTemplate->PrototypeTemplate()->Set(methodNameSync, methodCallSyncTemplate->GetFunction());
 
       if (java->DoPromise()) {
-        v8::Local<v8::Object> recv = NanNew<v8::Object>();
+        v8::Local<v8::Object> recv = Nan::New<v8::Object>();
         v8::Local<v8::Value> argv[] = { methodCallTemplate->GetFunction() };
         v8::Local<v8::Value> result = promisify->Call(recv, 1, argv);
         if (!result->IsFunction()) {
           fprintf(stderr, "Promisified result is not a function -- asyncOptions.promisify must return a function.\n");
           assert(result->IsFunction());
         }
         v8::Local<v8::Function> promFunction = result.As<v8::Function>();
-        v8::Handle<v8::String> methodNamePromise = NanNew<v8::String>((methodNameStr + java->PromiseSuffix()).c_str());
+        v8::Local<v8::String> methodNamePromise = Nan::New<v8::String>((methodNameStr + java->PromiseSuffix()).c_str()).ToLocalChecked();
         funcTemplate->PrototypeTemplate()->Set(methodNamePromise, promFunction);
       }
     }
@@ -87,22 +87,22 @@
       checkJavaException(env);
       std::string fieldNameStr = javaToString(env, fieldNameJava);
 
-      v8::Handle<v8::String> fieldName = NanNew<v8::String>(fieldNameStr.c_str());
-      funcTemplate->InstanceTemplate()->SetAccessor(fieldName, fieldGetter, fieldSetter);
+      v8::Local<v8::String> fieldName = Nan::New<v8::String>(fieldNameStr.c_str()).ToLocalChecked();
+      Nan::SetAccessor(funcTemplate->InstanceTemplate(), fieldName, fieldGetter, fieldSetter);
     }
 
-    v8::Persistent<v8::FunctionTemplate>* persistentFuncTemplate = new v8::Persistent<v8::FunctionTemplate>();
-    NanAssignPersistent(*persistentFuncTemplate, funcTemplate);
+    Nan::Persistent<v8::FunctionTemplate>* persistentFuncTemplate = new Nan::Persistent<v8::FunctionTemplate>();
+    persistentFuncTemplate->Reset(funcTemplate);
     sFunctionTemplates[className] = persistentFuncTemplate;
   }
 
   v8::Local<v8::Function> ctor = funcTemplate->GetFunction();
   v8::Local<v8::Object> javaObjectObj = ctor->NewInstance();
-  javaObjectObj->SetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT), NanNew<v8::Boolean>(true));
+  javaObjectObj->SetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), Nan::New<v8::Boolean>(true));
   JavaObject *self = new JavaObject(java, obj);
   self->Wrap(javaObjectObj);
 
-  return NanEscapeScope(javaObjectObj);
+  return scope.Escape(javaObjectObj);
 }
 
 JavaObject::JavaObject(Java *java, jobject obj) {
@@ -119,31 +119,32 @@ JavaObject::~JavaObject() {
 }
 
 NAN_METHOD(JavaObject::methodCall) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
-  v8::String::Utf8Value methodName(args.Data());
+  v8::String::Utf8Value methodName(info.Data());
   std::string methodNameStr = *methodName;
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
   // arguments
   ARGS_BACK_CALLBACK();
 
   if(!callbackProvided && methodNameStr == "toString") {
-    return methodCallSync(args);
+    return methodCallSync(info);
   }
 
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
 
   jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, args, argsStart, argsEnd);
+    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, info, argsStart, argsEnd);
     EXCEPTION_CALL_CALLBACK(self->m_java, msg);
-    NanReturnUndefined();
+    info.GetReturnValue().SetUndefined();
+    return;
   }
 
   // run
@@ -154,42 +155,44 @@ NAN_METHOD(JavaObject::methodCall) {
 }
 
 NAN_METHOD(JavaObject::methodCallSync) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
-  v8::String::Utf8Value methodName(args.Data());
+  v8::String::Utf8Value methodName(info.Data());
   std::string methodNameStr = *methodName;
 
   int argsStart = 0;
-  int argsEnd = args.Length();
+  int argsEnd = info.Length();
 
-  jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
+  jobjectArray methodArgs = v8ToJava(env, info, argsStart, argsEnd);
 
   jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs);
   if(method == NULL) {
-    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, args, argsStart, argsEnd);
-    v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, msg);
-    return NanThrowError(ex);
+    std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, info, argsStart, argsEnd);
+    v8::Local<v8::Value> ex = javaExceptionToV8(self->m_java, env, msg);
+    Nan::ThrowError(ex);
+    return;
   }
 
   // run
-  v8::Handle<v8::Value> callback = NanUndefined();
+  v8::Local<v8::Value> callback = Nan::Undefined();
   InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback);
-  v8::Handle<v8::Value> result = baton->runSync();
+  v8::Local<v8::Value> result = baton->runSync();
   delete baton;
 
   if(result->IsNativeError()) {
-    return NanThrowError(result);
+    Nan::ThrowError(result);
+    return;
   }
 
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_GETTER(JavaObject::fieldGetter) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
@@ -199,8 +202,9 @@ NAN_GETTER(JavaObject::fieldGetter) {
   if(field == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find field " << propertyStr;
-    v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
-    return NanThrowError(ex);
+    v8::Local<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(ex);
+    return;
   }
 
   jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
@@ -211,18 +215,19 @@ NAN_GETTER(JavaObject::fieldGetter) {
   if(env->ExceptionOccurred()) {
     std::ostringstream errStr;
     errStr << "Could not get field " << propertyStr;
-    v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
-    return NanThrowError(ex);
+    v8::Local<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(ex);
+    return;
   }
 
-  v8::Handle<v8::Value> result = javaToV8(self->m_java, env, val);
+  v8::Local<v8::Value> result = javaToV8(self->m_java, env, val);
 
-  NanReturnValue(result);
+  info.GetReturnValue().Set(result);
 }
 
 NAN_SETTER(JavaObject::fieldSetter) {
-  NanScope();
-  JavaObject* self = node::ObjectWrap::Unwrap<JavaObject>(args.This());
+  Nan::HandleScope scope;
+  JavaObject* self = Nan::ObjectWrap::Unwrap<JavaObject>(info.This());
   JNIEnv *env = self->m_java->getJavaEnv();
   JavaScope javaScope(env);
 
@@ -234,8 +239,8 @@ NAN_SETTER(JavaObject::fieldSetter) {
   if(field == NULL) {
     std::ostringstream errStr;
     errStr << "Could not find field " << propertyStr;
-    v8::Handle<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
-    NanThrowError(error);
+    v8::Local<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(error);
     return;
   }
 
@@ -249,38 +254,38 @@ NAN_SETTER(JavaObject::fieldSetter) {
   if(env->ExceptionOccurred()) {
     std::ostringstream errStr;
     errStr << "Could not set field " << propertyStr;
-    v8::Handle<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
-    NanThrowError(error);
+    v8::Local<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
+    Nan::ThrowError(error);
     return;
   }
 }
 
-/*static*/ v8::Persistent<v8::FunctionTemplate> JavaProxyObject::s_proxyCt;
+/*static*/ Nan::Persistent<v8::FunctionTemplate> JavaProxyObject::s_proxyCt;
 
 /*static*/ void JavaProxyObject::init() {
-  v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>();
-  NanAssignPersistent(s_proxyCt, t);
+  v8::Local<v8::FunctionTemplate> t = Nan::New<v8::FunctionTemplate>();
+  s_proxyCt.Reset(t);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<v8::String>("NodeDynamicProxy"));
+  t->SetClassName(Nan::New<v8::String>("NodeDynamicProxy").ToLocalChecked());
 
-  v8::Handle<v8::String> methodName = NanNew<v8::String>("unref");
-  v8::Local<v8::FunctionTemplate> methodCallTemplate = NanNew<v8::FunctionTemplate>(doUnref);
+  v8::Local<v8::String> methodName = Nan::New<v8::String>("unref").ToLocalChecked();
+  v8::Local<v8::FunctionTemplate> methodCallTemplate = Nan::New<v8::FunctionTemplate>(doUnref);
   t->PrototypeTemplate()->Set(methodName, methodCallTemplate->GetFunction());
 
-  v8::Handle<v8::String> fieldName = NanNew<v8::String>("invocationHandler");
-  t->InstanceTemplate()->SetAccessor(fieldName, invocationHandlerGetter);
+  v8::Local<v8::String> fieldName = Nan::New<v8::String>("invocationHandler").ToLocalChecked();
+  Nan::SetAccessor(t->InstanceTemplate(), fieldName, invocationHandlerGetter);
 }
 
 v8::Local<v8::Object> JavaProxyObject::New(Java *java, jobject obj, DynamicProxyData* dynamicProxyData) {
-  NanEscapableScope();
+  Nan::EscapableHandleScope scope;
 
-  v8::Local<v8::Function> ctor = NanNew(s_proxyCt)->GetFunction();
+  v8::Local<v8::Function> ctor = Nan::New(s_proxyCt)->GetFunction();
   v8::Local<v8::Object> javaObjectObj = ctor->NewInstance();
-  javaObjectObj->SetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT), NanNew<v8::Boolean>(true));
+  javaObjectObj->SetHiddenValue(Nan::New<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT).ToLocalChecked(), Nan::New<v8::Boolean>(true));
   JavaProxyObject *self = new JavaProxyObject(java, obj, dynamicProxyData);
   self->Wrap(javaObjectObj);
 
-  return NanEscapeScope(javaObjectObj);
+  return scope.Escape(javaObjectObj);
 }
 
 JavaProxyObject::JavaProxyObject(Java *java, jobject obj, DynamicProxyData* dynamicProxyData) : JavaObject(java, obj) {
@@ -294,19 +299,20 @@ JavaProxyObject::~JavaProxyObject() {
 }
 
 NAN_METHOD(JavaProxyObject::doUnref) {
-  JavaProxyObject* self = node::ObjectWrap::Unwrap<JavaProxyObject>(args.This());
+  JavaProxyObject* self = Nan::ObjectWrap::Unwrap<JavaProxyObject>(info.This());
   if (dynamicProxyDataVerify(self->m_dynamicProxyData)) {
     unref(self->m_dynamicProxyData);
   }
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_GETTER(JavaProxyObject::invocationHandlerGetter) {
- NanScope();
+ Nan::HandleScope scope;
 
- JavaProxyObject* self = node::ObjectWrap::Unwrap<JavaProxyObject>(args.This());
+ JavaProxyObject* self = Nan::ObjectWrap::Unwrap<JavaProxyObject>(info.This());
  if (!dynamicProxyDataVerify(self->m_dynamicProxyData)) {
-   return NanThrowError("dynamicProxyData has been destroyed or corrupted");
+   Nan::ThrowError("dynamicProxyData has been destroyed or corrupted");
+   return;
  }
- NanReturnValue(self->m_dynamicProxyData->functions);
+ info.GetReturnValue().Set(Nan::New(self->m_dynamicProxyData->functions));
 }