Merge pull request #702 from nodegit/bump-nan

Bump nan to v2

.travis.yml

@@ -1,7 +1,7 @@
 env:
   matrix:
     - export NODE_VERSION="0.12"
-    - export NODE_VERSION="iojs-v2.5.0"
+    - export NODE_VERSION="4.0"
 matrix:
   fast_finish: true
 before_install:

appveyor.yml

@@ -26,13 +26,10 @@ environment:
     # Node.js
     - nodejs_version: "0.12"
     # io.js
-    - nodejs_version: "2"
+    - nodejs_version: "3"
 
 matrix:
   fast_finish: true
-  allow_failures:
-    - nodejs_version: "0.10"
-    - nodejs_version: "2"
 
 # Get the latest stable version of Node 0.STABLE.latest
 install:

generate/templates/manual/include/callback_wrapper.h

@@ -10,7 +10,7 @@ using namespace v8;
 using namespace node;
 
 struct CallbackWrapper {
-  NanCallback* jsCallback;
+  Nan::Callback* jsCallback;
   void * payload;
 };
 

generate/templates/manual/include/git_buf_converter.h

@@ -10,7 +10,7 @@ using namespace v8;
 
 class StrArrayConverter {
   public:
-    static git_strarray *Convert (Handle<v8::Value> val);
+    static git_strarray *Convert (Local<v8::Value> val);
 };
 
 #endif

generate/templates/manual/include/str_array_converter.h

@@ -11,11 +11,11 @@ using namespace v8;
 class StrArrayConverter {
   public:
 
-    static git_strarray *Convert (Handle<v8::Value> val);
+    static git_strarray *Convert (Local<v8::Value> val);
 
   private:
     static git_strarray *ConvertArray(Array *val);
-    static git_strarray *ConvertString(Handle<String> val);
+    static git_strarray *ConvertString(Local<String> val);
     static git_strarray *AllocStrArray(const size_t count);
     static git_strarray *ConstructStrArray(int argc, char** argv);
 };

generate/templates/manual/include/wrapper.h

@@ -13,14 +13,14 @@
 using namespace node;
 using namespace v8;
 
-class Wrapper : public ObjectWrap {
+class Wrapper : public Nan::ObjectWrap {
   public:
 
-    static Persistent<FunctionTemplate> constructor_template;
-    static void InitializeComponent (Handle<v8::Object> target);
+    static Nan::Persistent<FunctionTemplate> constructor_template;
+    static void InitializeComponent (Local<v8::Object> target);
 
     void *GetValue();
-    static Handle<v8::Value> New(void *raw);
+    static Local<v8::Value> New(void *raw);
 
   private:
     Wrapper(void *raw);

generate/templates/manual/src/git_buf_converter.cc

@@ -9,7 +9,7 @@
 using namespace v8;
 using namespace node;
 
-git_buf *StrArrayConverter::Convert(Handle<v8::Value> val) {
+git_buf *StrArrayConverter::Convert(Local<v8::Value> val) {
   if (val->IsString() || val->IsStringObject()) {
     string v8String = ConvertString(val->ToString());
     const size_t size = sizeof(git_buf);

generate/templates/manual/src/str_array_converter.cc

@@ -9,7 +9,7 @@
 using namespace v8;
 using namespace node;
 
-git_strarray *StrArrayConverter::Convert(Handle<v8::Value> val) {
+git_strarray *StrArrayConverter::Convert(Local<v8::Value> val) {
   if (!val->BooleanValue()) {
     return NULL;
   }
@@ -37,16 +37,16 @@ git_strarray *StrArrayConverter::ConvertArray(Array *val) {
   git_strarray *result = AllocStrArray(val->Length());
 
   for(size_t i = 0; i < result->count; i++) {
-    NanUtf8String entry(val->Get(i));
+    Nan::Utf8String entry(val->Get(i));
     result->strings[i] = strdup(*entry);
   }
 
   return result;
 }
 
-git_strarray* StrArrayConverter::ConvertString(Handle<String> val) {
+git_strarray* StrArrayConverter::ConvertString(Local<String> val) {
   char *strings[1];
-  NanUtf8String utf8String(val);
+  Nan::Utf8String utf8String(val);
 
   strings[0] = *utf8String;
 

generate/templates/manual/src/wrapper.cc

@@ -16,67 +16,65 @@ Wrapper::Wrapper(void *raw) {
   this->raw = raw;
 }
 
-void Wrapper::InitializeComponent(Handle<v8::Object> target) {
-  NanScope();
+void Wrapper::InitializeComponent(Local<v8::Object> target) {
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(JSNewFunction);
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
 
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  tpl->SetClassName(NanNew<String>("Wrapper"));
+  tpl->SetClassName(Nan::New("Wrapper").ToLocalChecked());
 
-  NODE_SET_PROTOTYPE_METHOD(tpl, "toBuffer", ToBuffer);
+  Nan::SetPrototypeMethod(tpl, "toBuffer", ToBuffer);
 
-  NanAssignPersistent(constructor_template, tpl);
-  target->Set(NanNew<String>("Wrapper"), tpl->GetFunction());
+  constructor_template.Reset(tpl);
+  Nan::Set(target, Nan::New("Wrapper").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
 }
 
 NAN_METHOD(Wrapper::JSNewFunction) {
-  NanScope();
 
-  if (args.Length() == 0 || !args[0]->IsExternal()) {
-    return NanThrowError("void * is required.");
+  if (info.Length() == 0 || !info[0]->IsExternal()) {
+    return Nan::ThrowError("void * is required.");
   }
 
-  Wrapper* object = new Wrapper(External::Cast(*args[0])->Value());
-  object->Wrap(args.This());
+  Wrapper* object = new Wrapper(External::Cast(*info[0])->Value());
+  object->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
-Handle<v8::Value> Wrapper::New(void *raw) {
-  NanEscapableScope();
+Local<v8::Value> Wrapper::New(void *raw) {
+  Nan::EscapableHandleScope scope;
 
-  Handle<v8::Value> argv[1] = { NanNew<External>((void *)raw) };
+  Local<v8::Value> argv[1] = { Nan::New<External>((void *)raw) };
   Local<Object> instance;
-  Local<FunctionTemplate> constructorHandle = NanNew(constructor_template);
-  instance = constructorHandle->GetFunction()->NewInstance(1, argv);
+  Local<FunctionTemplate> constructorHandle = Nan::New(constructor_template);
+  instance = Nan::NewInstance(Nan::GetFunction(constructorHandle).ToLocalChecked(), 1, argv).ToLocalChecked();
 
-  return NanEscapeScope(instance);
+  return scope.Escape(instance);
 }
 
 void *Wrapper::GetValue() {
   return this->raw;
 }
 
 NAN_METHOD(Wrapper::ToBuffer) {
-  NanScope();
 
-  if(args.Length() == 0 || !args[0]->IsNumber()) {
-    return NanThrowError("Number is required.");
+  if(info.Length() == 0 || !info[0]->IsNumber()) {
+    return Nan::ThrowError("Number is required.");
   }
 
-  int len = args[0]->ToNumber()->Value();
+  int len = info[0]->ToNumber()->Value();
 
   Local<Function> bufferConstructor = Local<Function>::Cast(
-    NanGetCurrentContext()->Global()->Get(NanNew<String>("Buffer")));
+    Nan::Get(Nan::GetCurrentContext()->Global(), Nan::New("Buffer").ToLocalChecked()).ToLocalChecked());
 
-  Handle<v8::Value> constructorArgs[1] = { NanNew<Integer>(len) };
-  Local<Object> nodeBuffer = bufferConstructor->NewInstance(1, constructorArgs);
+  Local<v8::Value> constructorArgs[1] = { Nan::New(len) };
+  Local<Object> nodeBuffer = Nan::NewInstance(bufferConstructor, 1, constructorArgs).ToLocalChecked();
 
-  std::memcpy(node::Buffer::Data(nodeBuffer), ObjectWrap::Unwrap<Wrapper>(args.This())->GetValue(), len);
+  std::memcpy(node::Buffer::Data(nodeBuffer), Nan::ObjectWrap::Unwrap<Wrapper>(info.This())->GetValue(), len);
 
-  NanReturnValue(nodeBuffer);
+  info.GetReturnValue().Set(nodeBuffer);
 }
 
 
-Persistent<FunctionTemplate> Wrapper::constructor_template;
+Nan::Persistent<FunctionTemplate> Wrapper::constructor_template;

generate/templates/partials/async_function.cc

@@ -1,10 +1,9 @@
 
 {%partial doc .%}
 NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
-  NanScope();
   {%partial guardArguments .%}
-  if (args.Length() == {{args|jsArgsCount}} || !args[{{args|jsArgsCount}}]->IsFunction()) {
-    return NanThrowError("Callback is required and must be a Function.");
+  if (info.Length() == {{args|jsArgsCount}} || !info[{{args|jsArgsCount}}]->IsFunction()) {
+    return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
   {{ cppFunctionName }}Baton* baton = new {{ cppFunctionName }}Baton;
@@ -26,9 +25,9 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
-  baton->{{ arg.name }} = ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue();
+  baton->{{ arg.name }} = Nan::ObjectWrap::Unwrap<{{ arg.cppClassName }}>(info.This())->GetValue();
       {%elsif arg.isCallbackFunction %}
-  if (!args[{{ arg.jsArg }}]->IsFunction()) {
+  if (!info[{{ arg.jsArg }}]->IsFunction()) {
     baton->{{ arg.name }} = NULL;
         {%if arg.payload.globalPayload %}
     globalPayload->{{ arg.name }} = NULL;
@@ -39,9 +38,9 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
   else {
     baton->{{ arg.name}} = {{ cppFunctionName }}_{{ arg.name }}_cppCallback;
         {%if arg.payload.globalPayload %}
-    globalPayload->{{ arg.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+    globalPayload->{{ arg.name }} = new Nan::Callback(info[{{ arg.jsArg }}].As<Function>());
         {%else%}
-    baton->{{ arg.payload.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+    baton->{{ arg.payload.name }} = new Nan::Callback(info[{{ arg.jsArg }}].As<Function>());
         {%endif%}
   }
       {%elsif arg.payloadFor %}
@@ -53,7 +52,7 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
         {%if not arg.payloadFor %}
   baton->{{ arg.name }} = from_{{ arg.name }};
           {%if arg | isOid %}
-  baton->{{ arg.name }}NeedsFree = args[{{ arg.jsArg }}]->IsString();
+  baton->{{ arg.name }}NeedsFree = info[{{ arg.jsArg }}]->IsString();
           {%endif%}
         {%endif%}
       {%endif%}
@@ -62,21 +61,21 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
     {%endif%}
   {%endeach%}
 
-  NanCallback *callback = new NanCallback(Local<Function>::Cast(args[{{args|jsArgsCount}}]));
+  Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[{{args|jsArgsCount}}]));
   {{ cppFunctionName }}Worker *worker = new {{ cppFunctionName }}Worker(baton, callback);
   {%each args|argsInfo as arg %}
     {%if not arg.isReturn %}
       {%if arg.isSelf %}
-  worker->SaveToPersistent("{{ arg.name }}", args.This());
+  worker->SaveToPersistent("{{ arg.name }}", info.This());
       {%elsif not arg.isCallbackFunction %}
-  if (!args[{{ arg.jsArg }}]->IsUndefined() && !args[{{ arg.jsArg }}]->IsNull())
-    worker->SaveToPersistent("{{ arg.name }}", args[{{ arg.jsArg }}]->ToObject());
+  if (!info[{{ arg.jsArg }}]->IsUndefined() && !info[{{ arg.jsArg }}]->IsNull())
+    worker->SaveToPersistent("{{ arg.name }}", info[{{ arg.jsArg }}]->ToObject());
       {%endif%}
     {%endif%}
   {%endeach%}
 
-  NanAsyncQueueWorker(worker);
-  NanReturnUndefined();
+  Nan::AsyncQueueWorker(worker);
+  return;
 }
 
 void {{ cppClassName }}::{{ cppFunctionName }}Worker::Execute() {
@@ -110,31 +109,31 @@ void {{ cppClassName }}::{{ cppFunctionName }}Worker::Execute() {
 void {{ cppClassName }}::{{ cppFunctionName }}Worker::HandleOKCallback() {
   if (baton->error_code == GIT_OK) {
     {%if not .|returnsCount %}
-    Handle<v8::Value> result = NanUndefined();
+    Local<v8::Value> result = Nan::Undefined();
     {%else%}
-    Handle<v8::Value> to;
+    Local<v8::Value> to;
       {%if .|returnsCount > 1 %}
-    Handle<Object> result = NanNew<Object>();
+    Local<Object> result = Nan::New<Object>();
       {%endif%}
       {%each .|returnsInfo 0 1 as _return %}
         {%partial convertToV8 _return %}
         {%if .|returnsCount > 1 %}
-    result->Set(NanNew<String>("{{ _return.returnNameOrName }}"), to);
+    Nan::Set(result, Nan::New("{{ _return.returnNameOrName }}").ToLocalChecked(), to);
         {%endif%}
       {%endeach%}
       {%if .|returnsCount == 1 %}
-    Handle<v8::Value> result = to;
+    Local<v8::Value> result = to;
       {%endif%}
     {%endif%}
-    Handle<v8::Value> argv[2] = {
-      NanNull(),
+    Local<v8::Value> argv[2] = {
+      Nan::Null(),
       result
     };
     callback->Call(2, argv);
   } else {
     if (baton->error) {
-      Handle<v8::Value> argv[1] = {
-        NanError(baton->error->message)
+      Local<v8::Value> argv[1] = {
+        Nan::Error(baton->error->message)
       };
       callback->Call(1, argv);
       if (baton->error->message)