upgrade to NAN v2

package.json

@@ -31,7 +31,7 @@
     "abstract-leveldown": "~2.4.0",
     "bindings": "~1.2.1",
     "fast-future": "~1.0.0",
-    "nan": "~1.8.4",
+    "nan": "nodejs/nan#next",
     "node-pre-gyp": "~0.6.2"
   },
   "devDependencies": {

src/async.h

@@ -14,16 +14,12 @@ namespace leveldown {
 
 class Database;
 
-/* abstract */ class AsyncWorker : public NanAsyncWorker {
+/* abstract */ class AsyncWorker : public Nan::AsyncWorker {
 public:
   AsyncWorker (
       leveldown::Database* database
-    , NanCallback *callback
-  ) : NanAsyncWorker(callback), database(database) {
-    NanScope();
-    v8::Local<v8::Object> obj = NanNew<v8::Object>();
-    NanAssignPersistent(persistentHandle, obj);
-  }
+    , Nan::Callback *callback
+  ) : Nan::AsyncWorker(callback), database(database) { }
 
 protected:
   void SetStatus(leveldb::Status status) {

src/batch.cc

@@ -9,7 +9,7 @@
 
 namespace leveldown {
 
-static v8::Persistent<v8::FunctionTemplate> batch_constructor;
+static Nan::Persistent<v8::FunctionTemplate> batch_constructor;
 
 Batch::Batch (leveldown::Database* database, bool sync) : database(database) {
   options = new leveldb::WriteOptions();
@@ -28,45 +28,43 @@ leveldb::Status Batch::Write () {
 }
 
 void Batch::Init () {
-  v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(Batch::New);
-  NanAssignPersistent(batch_constructor, tpl);
-  tpl->SetClassName(NanNew("Batch"));
+  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(Batch::New);
+  batch_constructor.Reset(tpl);
+  tpl->SetClassName(Nan::New("Batch").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  NODE_SET_PROTOTYPE_METHOD(tpl, "put", Batch::Put);
-  NODE_SET_PROTOTYPE_METHOD(tpl, "del", Batch::Del);
-  NODE_SET_PROTOTYPE_METHOD(tpl, "clear", Batch::Clear);
-  NODE_SET_PROTOTYPE_METHOD(tpl, "write", Batch::Write);
+  Nan::SetPrototypeMethod(tpl, "put", Batch::Put);
+  Nan::SetPrototypeMethod(tpl, "del", Batch::Del);
+  Nan::SetPrototypeMethod(tpl, "clear", Batch::Clear);
+  Nan::SetPrototypeMethod(tpl, "write", Batch::Write);
 }
 
 NAN_METHOD(Batch::New) {
-  NanScope();
-
-  Database* database = node::ObjectWrap::Unwrap<Database>(args[0]->ToObject());
+  Database* database = Nan::ObjectWrap::Unwrap<Database>(info[0]->ToObject());
   v8::Local<v8::Object> optionsObj;
 
-  if (args.Length() > 1 && args[1]->IsObject()) {
-    optionsObj = v8::Local<v8::Object>::Cast(args[1]);
+  if (info.Length() > 1 && info[1]->IsObject()) {
+    optionsObj = v8::Local<v8::Object>::Cast(info[1]);
   }
 
   bool sync = BooleanOptionValue(optionsObj, "sync");
 
   Batch* batch = new Batch(database, sync);
-  batch->Wrap(args.This());
+  batch->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 v8::Handle<v8::Value> Batch::NewInstance (
         v8::Handle<v8::Object> database
       , v8::Handle<v8::Object> optionsObj
     ) {
 
-  NanEscapableScope();
+  Nan::EscapableHandleScope scope;
 
   v8::Local<v8::Object> instance;
 
   v8::Local<v8::FunctionTemplate> constructorHandle =
-      NanNew<v8::FunctionTemplate>(batch_constructor);
+      Nan::New<v8::FunctionTemplate>(batch_constructor);
 
   if (optionsObj.IsEmpty()) {
     v8::Handle<v8::Value> argv[1] = { database };
@@ -76,17 +74,15 @@ v8::Handle<v8::Value> Batch::NewInstance (
     instance = constructorHandle->GetFunction()->NewInstance(2, argv);
   }
 
-  return NanEscapeScope(instance);
+  return scope.Escape(instance);
 }
 
 NAN_METHOD(Batch::Put) {
-  NanScope();
-
-  Batch* batch = ObjectWrap::Unwrap<Batch>(args.Holder());
+  Batch* batch = ObjectWrap::Unwrap<Batch>(info.Holder());
   v8::Handle<v8::Function> callback; // purely for the error macros
 
-  v8::Local<v8::Value> keyBuffer = args[0];
-  v8::Local<v8::Value> valueBuffer = args[1];
+  v8::Local<v8::Value> keyBuffer = info[0];
+  v8::Local<v8::Value> valueBuffer = info[1];
   LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, key)
   LD_STRING_OR_BUFFER_TO_SLICE(value, valueBuffer, value)
 
@@ -97,17 +93,15 @@ NAN_METHOD(Batch::Put) {
   DisposeStringOrBufferFromSlice(keyBuffer, key);
   DisposeStringOrBufferFromSlice(valueBuffer, value);
 
-  NanReturnValue(args.Holder());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 NAN_METHOD(Batch::Del) {
-  NanScope();
-
-  Batch* batch = ObjectWrap::Unwrap<Batch>(args.Holder());
+  Batch* batch = ObjectWrap::Unwrap<Batch>(info.Holder());
 
   v8::Handle<v8::Function> callback; // purely for the error macros
 
-  v8::Local<v8::Value> keyBuffer = args[0];
+  v8::Local<v8::Value> keyBuffer = info[0];
   LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, key)
 
   batch->batch->Delete(key);
@@ -116,38 +110,32 @@ NAN_METHOD(Batch::Del) {
 
   DisposeStringOrBufferFromSlice(keyBuffer, key);
 
-  NanReturnValue(args.Holder());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 NAN_METHOD(Batch::Clear) {
-  NanScope();
-
-  Batch* batch = ObjectWrap::Unwrap<Batch>(args.Holder());
+  Batch* batch = ObjectWrap::Unwrap<Batch>(info.Holder());
 
   batch->batch->Clear();
   batch->hasData = false;
 
-  NanReturnValue(args.Holder());
+  info.GetReturnValue().Set(info.Holder());
 }
 
 NAN_METHOD(Batch::Write) {
-  NanScope();
-
-  Batch* batch = ObjectWrap::Unwrap<Batch>(args.Holder());
+  Batch* batch = ObjectWrap::Unwrap<Batch>(info.Holder());
 
   if (batch->hasData) {
-    NanCallback *callback =
-        new NanCallback(v8::Local<v8::Function>::Cast(args[0]));
+    Nan::Callback *callback =
+        new Nan::Callback(v8::Local<v8::Function>::Cast(info[0]));
     BatchWriteWorker* worker  = new BatchWriteWorker(batch, callback);
     // persist to prevent accidental GC
-    v8::Local<v8::Object> _this = args.This();
+    v8::Local<v8::Object> _this = info.This();
     worker->SaveToPersistent("batch", _this);
-    NanAsyncQueueWorker(worker);
+    Nan::AsyncQueueWorker(worker);
   } else {
-    LD_RUN_CALLBACK(v8::Local<v8::Function>::Cast(args[0]), 0, NULL);
+    LD_RUN_CALLBACK(v8::Local<v8::Function>::Cast(info[0]), 0, NULL);
   }
-
-  NanReturnUndefined();
 }
 
 } // namespace leveldown

src/batch.h

@@ -10,7 +10,7 @@
 
 namespace leveldown {
 
-class Batch : public node::ObjectWrap {
+class Batch : public Nan::ObjectWrap {
 public:
   static void Init();
   static v8::Handle<v8::Value> NewInstance (

src/batch_async.cc

@@ -14,7 +14,7 @@ namespace leveldown {
 
 BatchWriteWorker::BatchWriteWorker (
     Batch* batch
-  , NanCallback *callback
+  , Nan::Callback *callback
 ) : AsyncWorker(NULL, callback)
   , batch(batch)
 {};

src/batch_async.h

@@ -19,7 +19,7 @@ class BatchWriteWorker : public AsyncWorker {
 public:
   BatchWriteWorker (
       Batch* batch
-    , NanCallback *callback
+    , Nan::Callback *callback
   );
 
   virtual ~BatchWriteWorker ();

src/common.h

@@ -13,7 +13,7 @@ namespace leveldown {
 NAN_INLINE bool BooleanOptionValue(v8::Local<v8::Object> options,
                                    const char* _key,
                                    bool def = false) {
-  v8::Handle<v8::String> key = NanNew(_key);
+  v8::Handle<v8::String> key = Nan::New(_key).ToLocalChecked();
   return !options.IsEmpty()
     && options->Has(key)
     ? options->Get(key)->BooleanValue()
@@ -23,7 +23,7 @@ NAN_INLINE bool BooleanOptionValue(v8::Local<v8::Object> options,
 NAN_INLINE uint32_t UInt32OptionValue(v8::Local<v8::Object> options,
                                       const char* _key,
                                       uint32_t def) {
-  v8::Handle<v8::String> key = NanNew(_key);
+  v8::Handle<v8::String> key = Nan::New(_key).ToLocalChecked();
   return !options.IsEmpty()
     && options->Has(key)
     && options->Get(key)->IsNumber()