diff --git a/.npmignore b/.npmignore index 1980fa872..5b5b9304e 100644 --- a/.npmignore +++ b/.npmignore @@ -1,6 +1,4 @@ -docs/ -example/ -test/ -util/ -vendor/nodeunit -vendor/rimraf +/doc/ +/example/ +/node_modules/ +/test/ diff --git a/.travis.yml b/.travis.yml index 0604aaedf..8be0a1110 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,6 +1,5 @@ language: node_js node_js: - - 0.8 - "0.10" - 0.11 git: diff --git a/README.md b/README.md index ae7ba817b..c2e03d931 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ NodeGit Status](https://travis-ci.org/tbranyen/nodegit.png)](https://travis-ci.org/nodegit/nodegit) Build Status: Windows -**Stable: 0.1.3** +**Stable: 0.1.4** Maintained by Tim Branyen [@tbranyen](http://twitter.com/tbranyen), Michael Robinson [@codeofinterest](http://twitter.com/codeofinterest), and Nick Kallen @@ -18,18 +18,23 @@ contributors](https://github.com/tbranyen/nodegit/contributors)! http://www.nodegit.org/nodegit/ -## Building and Installing. ## +## Getting started. ## -Minimum dependencies: - -* [Python 2](https://www.python.org/) -* [CMake >= 2.8](http://www.cmake.org/) +NodeGit will work on most systems out-of-the-box without any native +dependencies. ``` bash npm install nodegit ``` -### Building manually: ### +If you encounter problems while installing, you should try the Building from +source instructions below. + +## Building from source. ## + +Minimum dependencies: + +- [Python 2](https://www.python.org/) If you wish to help contribute to nodegit it is useful to build locally. @@ -49,31 +54,26 @@ correctly. ### Installing dependencies: ### -#### OS X #### +#### Mac OS X #### -Using Brew: - -``` bash -brew install cmake libzip -``` +- [Install XCode Command Line Tools](http://railsapps.github.io/xcode-command-line-tools.html) #### Linux #### Using APT in Ubuntu: ``` bash -sudo apt-get install cmake libzip-dev build-essential +sudo apt-get install build-essential ``` Using Pacman in Arch Linux: ``` bash -sudo pacman -S cmake libzip base-devel +sudo pacman -S base-devel ``` #### Windows #### -- [Download and install CMake](http://www.cmake.org/cmake/resources/software.html). - [Download and install Python](https://www.python.org/download/windows). - [Download and install VS Express](http://www.visualstudio.com/downloads/download-visual-studio-vs#d-express-windows-desktop). @@ -107,13 +107,13 @@ clone("https://github.com/nodegit/nodegit", "tmp", null, function(err, repo) { // Look up this known commit. repo.getCommit(sha, function(err, commit) { if (err) { - throw error; + throw err; } // Look up a specific file within that commit. commit.getEntry("README.md", function(err, entry) { if (err) { - throw error; + throw err; } // Get the blob contents from the file. diff --git a/appveyor.yml b/appveyor.yml index 5dfc10162..8c99db391 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -14,7 +14,6 @@ environment: matrix: - nodejs_version: 0.11 - nodejs_version: 0.10 - - nodejs_version: 0.8 matrix: allow_failures: diff --git a/binding.gyp b/binding.gyp index 6233c2826..104b7a9d3 100644 --- a/binding.gyp +++ b/binding.gyp @@ -3,6 +3,10 @@ { "target_name": "nodegit", + "dependencies": [ + "libgit2" + ], + "sources": [ "src/base.cc", "src/blob.cc", @@ -46,35 +50,374 @@ ], "cflags": [ - "-Wall" - ], - - "ldflags": [ - "-Wl,-rpath,\$$ORIGIN/../../vendor/libgit2/build" + "-Wall", ], "conditions": [ - [ - "OS=='win'", { - "libraries": [ - "-l../vendor/libgit2/build/Debug/git2.lib" - ], - }, { # 'OS!="win"' - "libraries": [ - "-L */ -Handle <%- cppClassName %>::<%- functionInfo.cppFunctionName %>(const Arguments& args) { - HandleScope scope; +NAN_METHOD(<%- cppClassName %>::<%- functionInfo.cppFunctionName %>) { + NanScope(); <% var jsArg; -%> <% include guardArguments.cc.ejs -%> if (args.Length() == <%- jsArg %> || !args[<%- jsArg %>]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } <%- functionInfo.cppFunctionName %>Baton* baton = new <%- functionInfo.cppFunctionName %>Baton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; <% for (var cArg = 0, jsArg = 0; cArg < functionInfo.args.length; cArg++) { var arg = functionInfo.args[cArg]; -%> <% if (!arg.isReturn) { -%> <% if (arg.isSelf) { -%> - baton-><%- arg.name %>Reference = Persistent::New(args.This()); baton-><%- arg.name %> = ObjectWrap::Unwrap<<%- cppClassName %>>(args.This())->GetValue(); <% } else { -%> - baton-><%- arg.name %>Reference = Persistent::New(args[<%- jsArg %>]); <% include convertFromV8.cc.ejs -%> <% if (!arg.isPayload) { -%> baton-><%- arg.name %> = from_<%- arg.name %>; @@ -35,19 +32,32 @@ Handle <%- cppClassName %>::<%- functionInfo.cppFunctionName %>(const Arg <% } else { -%> <% if (arg.shouldAlloc) { -%> baton-><%- arg.name %> = (<%- arg.cType %>)malloc(sizeof(<%- arg.cType.replace('*', '') %>)); -<% } else { -%> <% } -%> <% } -%> <% } -%> - baton->callback = Persistent::New(Local::Cast(args[<%- jsArg %>])); - uv_queue_work(uv_default_loop(), &baton->request, <%- functionInfo.cppFunctionName %>Work, (uv_after_work_cb)<%- functionInfo.cppFunctionName %>AfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[<%- jsArg %>])); + <%- functionInfo.cppFunctionName %>Worker *worker = new <%- functionInfo.cppFunctionName %>Worker(baton, callback); +<% + for (var cArg = 0, jsArg = 0; cArg < functionInfo.args.length; cArg++) { + var arg = functionInfo.args[cArg]; +-%> +<% if (!arg.isReturn) { -%> +<% if (arg.isSelf) { -%> + worker->SaveToPersistent("<%- arg.name %>", args.This()); +<% } else { -%> + if (!args[<%- jsArg %>]->IsUndefined() && !args[<%- jsArg %>]->IsNull()) + worker->SaveToPersistent("<%- arg.name %>", args[<%- jsArg %>]->ToObject()); +<% } -%> +<% if (!(arg.isReturn || arg.isSelf || arg.isPayload)) jsArg++; -%> +<% } -%> +<% } -%> - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void <%- cppClassName %>::<%- functionInfo.cppFunctionName %>Work(uv_work_t *req) { - <%- functionInfo.cppFunctionName %>Baton *baton = static_cast<<%- functionInfo.cppFunctionName %>Baton *>(req->data); +void <%- cppClassName %>::<%- functionInfo.cppFunctionName %>Worker::Execute() { <% if (functionInfo.return.cType != "void" || functionInfo.return.isErrorCode) { %><%- functionInfo.return.cType %> result = <% } %><%- functionInfo.cFunctionName %>( <% for (var i = 0; i < functionInfo.args.length; i++) { @@ -66,46 +76,43 @@ void <%- cppClassName %>::<%- functionInfo.cppFunctionName %>Work(uv_work_t *req <% } -%> } -void <%- cppClassName %>::<%- functionInfo.cppFunctionName %>AfterWork(uv_work_t *req) { - HandleScope scope; - <%- functionInfo.cppFunctionName %>Baton *baton = static_cast<<%- functionInfo.cppFunctionName %>Baton *>(req->data); - +void <%- cppClassName %>::<%- functionInfo.cppFunctionName %>Worker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { <% if (!returns.length) { -%> - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); <% } else if (returns.length == 1) { -%> <% var to = {}; to.__proto__ = returns[0]; to.name = "baton->" + to.name; -%> Handle to; <% include convertToV8.cc.ejs -%> Handle result = to; <% } else { -%> - Handle result = Object::New(); + Handle result = NanNew(); Handle to; <% for (r in returns) { var to = returns[r]; -%> <% include convertToV8.cc.ejs -%> - result->Set(String::NewSymbol("<%- to.jsName || to.name %>"), to); + result->Set(NanNew("<%- to.jsName || to.name %>"), to); <% } -%> <% } -%> Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } <% for (var i = 0; i < functionInfo.args.length; i++) { @@ -119,14 +126,6 @@ void <%- cppClassName %>::<%- functionInfo.cppFunctionName %>AfterWork(uv_work_t if (try_catch.HasCaught()) { node::FatalException(try_catch); } -<% - for (var i = 0, j = 0; i < functionInfo.args.length; i++) { - var arg = functionInfo.args[i]; - if (arg.isReturn) continue; --%> - baton-><%- arg.name %>Reference.Dispose(); -<% } -%> - baton->callback.Dispose(); <% for (var i = 0; i < functionInfo.args.length; i++) { var arg = functionInfo.args[i]; diff --git a/build/codegen/templates/class.cc.ejs b/build/codegen/templates/class.cc.ejs index 4cce71562..5bae84441 100644 --- a/build/codegen/templates/class.cc.ejs +++ b/build/codegen/templates/class.cc.ejs @@ -26,8 +26,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -56,12 +55,12 @@ using namespace node; } void <%- cppClassName %>::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("<%- jsClassName %>")); + tpl->SetClassName(NanNew("<%- jsClassName %>")); <% if (typeof functions != 'undefined') { -%> <% @@ -87,27 +86,27 @@ void <%- cppClassName %>::Initialize(Handle target) { <% } -%> <% } -%> - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("<%- jsClassName %>"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("<%- jsClassName %>"), _constructor_template); } -Handle <%- cppClassName %>::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(<%- cppClassName %>::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("<%= cType %> is required."))); + return NanThrowError("<%= cType %> is required."); } - - <%- cppClassName %>* object = new <%- cppClassName %>((<%= cType%> *) External::Unwrap(args[0])); + <%- cppClassName %>* object = new <%- cppClassName %>(static_cast<<%= cType%> *>(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle <%- cppClassName %>::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(<%- cppClassName %>::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(<%- cppClassName %>::constructor_template)->NewInstance(1, argv)); } <%- cType %> *<%- cppClassName %>::GetValue() { @@ -115,9 +114,9 @@ Handle <%- cppClassName %>::New(void *raw) { } <% } else { -%> void <%- cppClassName %>::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Persistent object = Persistent::New(Object::New()); + Local object = NanNew(); <% if (typeof functions != 'undefined') { -%> <% @@ -125,11 +124,11 @@ void <%- cppClassName %>::Initialize(Handle target) { var functionInfo = functions[i]; if (functionInfo.ignore) continue; -%> - object->Set(String::NewSymbol("<%- functionInfo.jsFunctionName %>"), FunctionTemplate::New(<%- functionInfo.cppFunctionName %>)->GetFunction()); + NODE_SET_METHOD(object, "<%- functionInfo.jsFunctionName %>", <%- functionInfo.cppFunctionName %>); <% } -%> <% } -%> - target->Set(String::NewSymbol("<%- jsClassName %>"), object); + target->Set(NanNew("<%- jsClassName %>"), object); } <% } -%> diff --git a/build/codegen/templates/convertFromV8.cc.ejs b/build/codegen/templates/convertFromV8.cc.ejs index d1a442e34..acc5d5044 100644 --- a/build/codegen/templates/convertFromV8.cc.ejs +++ b/build/codegen/templates/convertFromV8.cc.ejs @@ -13,10 +13,9 @@ <% // FIXME: should recursively call convertFromv8. %> - from_<%- arg.name %>[i] = ObjectWrap::Unwrap<<%- arg.arrayElementCppClassName %>>(tmp_<%- arg.name %>->Get(Number::New(static_cast(i)))->ToObject())->GetValue(); + from_<%- arg.name %>[i] = ObjectWrap::Unwrap<<%- arg.arrayElementCppClassName %>>(tmp_<%- arg.name %>->Get(NanNew(static_cast(i)))->ToObject())->GetValue(); } <% } else if (arg.cppClassName == "Function") { -%> - Persistent::New(Local::Cast(args[<%- jsArg %>])); <% } else if (arg.cppClassName == 'Buffer') { -%> from_<%- arg.name %> = Buffer::Data(args[<%- jsArg %>]->ToObject()); <% } else if (isV8Value(arg.cppClassName)) { -%> diff --git a/build/codegen/templates/convertToV8.cc.ejs b/build/codegen/templates/convertToV8.cc.ejs index 9918d948d..aefae8386 100644 --- a/build/codegen/templates/convertToV8.cc.ejs +++ b/build/codegen/templates/convertToV8.cc.ejs @@ -1,24 +1,29 @@ <% toName = to.name || 'result' -%> <% if (to.cppClassName == "String") { -%> <% if (typeof to.size != 'undefined') { -%> - to = String::New(<%- toName %>, <%- to.size %>); + to = NanNew(<%- toName %>, <%- to.size %>); <% } else { -%> - to = String::New(<%- toName %>); + to = NanNew(<%- toName %>); <% } -%> <% if (to.freeFunctionName) { -%> <%- to.freeFunctionName %>(<%- toName %>); <% } -%> <% } else if (isV8Value(to.cppClassName)) { -%> - to = <%- to.cppClassName %>::New(<%- toName %>); +<% if (~['Uint32', 'Int32'].indexOf(to.cppClassName)) { -%> +<% var className = to.cppClassName.toLowerCase()+'_t' -%> + to = NanNew<<%- to.cppClassName %>>((<%- className %>)<%- toName %>); +<% } else { -%> + to = NanNew<<%- to.cppClassName %>>(<%- toName %>); +<% } -%> <% } else if (to.cppClassName == "External") { -%> - to = External::New((void *)<%- toName %>); + to = NanNew((void *)<%- toName %>); <% } else if (to.cppClassName == 'Array') { -%> <% // FIXME this is not general purpose enough. %> - Local tmpArray = Array::New(<%- toName %>-><%- to.size %>); + Local tmpArray = NanNew(<%- toName %>-><%- to.size %>); for (unsigned int i = 0; i < <%- toName %>-><%- to.size %>; i++) { - tmpArray->Set(Number::New(i), String::New(<%- toName %>-><%- to.key %>[i])); + tmpArray->Set(NanNew(i), NanNew(<%- toName %>-><%- to.key %>[i])); } to = tmpArray; <% } else { -%> @@ -30,6 +35,6 @@ if (<%- toName %> != NULL) { to = <%- to.cppClassName %>::New((void *)<%- toName %>); } else { - to = Null(); + to = NanNull(); } <% } -%> diff --git a/build/codegen/templates/fields.cc.ejs b/build/codegen/templates/fields.cc.ejs index 44c8fcb57..f7f684a99 100644 --- a/build/codegen/templates/fields.cc.ejs +++ b/build/codegen/templates/fields.cc.ejs @@ -5,8 +5,8 @@ if (fieldInfo.ignore) continue; -%> -Handle <%- cppClassName %>::<%- fieldInfo.cppFunctionName %>(const Arguments& args) { - HandleScope scope; +NAN_METHOD(<%- cppClassName %>::<%- fieldInfo.cppFunctionName %>) { + NanScope(); <% var to = fieldInfo; -%> Handle to; @@ -14,7 +14,7 @@ Handle <%- cppClassName %>::<%- fieldInfo.cppFunctionName %>(const Argume <% if (!isV8Value(fieldInfo.cppClassName)) { %>&<% } %>ObjectWrap::Unwrap<<%- cppClassName %>>(args.This())->GetValue()-><%- fieldInfo.name %>; <% include convertToV8.cc.ejs -%> - return scope.Close(to); + NanReturnValue(to); } <% } -%> <% } -%> diff --git a/build/codegen/templates/guardArguments.cc.ejs b/build/codegen/templates/guardArguments.cc.ejs index a238d32e9..99a99fb0f 100644 --- a/build/codegen/templates/guardArguments.cc.ejs +++ b/build/codegen/templates/guardArguments.cc.ejs @@ -6,7 +6,7 @@ -%> <% if (!arg.isOptional) { -%> if (args.Length() == <%- jsArg %> || !args[<%- jsArg %>]->Is<%- cppClassName2v8ValueClassName(arg.cppClassName) %>()) { - return ThrowException(Exception::Error(String::New("<%- arg.jsClassName %> <%- arg.name %> is required."))); + return NanThrowError("<%- arg.jsClassName %> <%- arg.name %> is required."); } <% } -%> <% jsArg++; -%> diff --git a/build/codegen/templates/header.h.ejs b/build/codegen/templates/header.h.ejs index 1a31a7fe7..1d7e373cb 100644 --- a/build/codegen/templates/header.h.ejs +++ b/build/codegen/templates/header.h.ejs @@ -5,8 +5,7 @@ #ifndef <%- cppClassName.toUpperCase() %>_H #define <%- cppClassName.toUpperCase() %>_H -#include -#include +#include #include #include "git2.h" @@ -32,7 +31,7 @@ class <%- cppClassName %> : public ObjectWrap { ~<%- cppClassName %>(); <% } -%> - static Handle New(const Arguments& args); + static NAN_METHOD(New); <% if (typeof fields != 'undefined') { -%> <% @@ -40,23 +39,18 @@ class <%- cppClassName %> : public ObjectWrap { var fieldInfo = fields[i]; if (fieldInfo.ignore) continue; -%> - static Handle <%- fieldInfo.cppFunctionName %>(const Arguments& args); + static NAN_METHOD(<%- fieldInfo.cppFunctionName %>); <% } -%> <% } -%> - <% if (typeof functions != 'undefined') { -%> <% for (var i in functions) { var functionInfo = functions[i]; if (functionInfo.ignore) continue; -%> - static Handle <%- functionInfo.cppFunctionName %>(const Arguments& args); <% if (functionInfo.isAsync) { -%> - static void <%- functionInfo.cppFunctionName %>Work(uv_work_t* req); - static void <%- functionInfo.cppFunctionName %>AfterWork(uv_work_t* req); struct <%- functionInfo.cppFunctionName %>Baton { - uv_work_t request; int error_code; const git_error* error; <% @@ -66,13 +60,26 @@ class <%- cppClassName %> : public ObjectWrap { <% if (arg.isReturn) { -%> <%- arg.cType.replace('**', '*') %> <%- arg.name %>; <% } else { -%> - Persistent <%- arg.name %>Reference; <%- arg.cType %> <%- arg.name %>; <% } -%> <% } -%> - Persistent callback; + }; + class <%- functionInfo.cppFunctionName %>Worker : public NanAsyncWorker { + public: + <%- functionInfo.cppFunctionName %>Worker( + <%- functionInfo.cppFunctionName %>Baton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~<%- functionInfo.cppFunctionName %>Worker() {}; + void Execute(); + void HandleOKCallback(); + + private: + <%- functionInfo.cppFunctionName %>Baton *baton; }; <% } -%> + static NAN_METHOD(<%- functionInfo.cppFunctionName %>); <% } -%> <% } -%> <% if (typeof cType != 'undefined') { -%> diff --git a/build/codegen/templates/syncFunction.cc.ejs b/build/codegen/templates/syncFunction.cc.ejs index a7c00aa05..ad5349a35 100644 --- a/build/codegen/templates/syncFunction.cc.ejs +++ b/build/codegen/templates/syncFunction.cc.ejs @@ -1,8 +1,8 @@ /** <% include doc.cc.ejs -%> */ -Handle <%- cppClassName %>::<%- functionInfo.cppFunctionName %>(const Arguments& args) { - HandleScope scope; +NAN_METHOD(<%- cppClassName %>::<%- functionInfo.cppFunctionName %>) { + NanScope(); <% include guardArguments.cc.ejs -%> <% @@ -65,31 +65,31 @@ from_<%- arg.name %> free(<%= arg.name %>); <% } -%> if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } <% } -%> <% if (!returns.length) { -%> - return Undefined(); + NanReturnUndefined(); <% } else if (returns.length == 1) { -%> <% var to = returns[0]; -%> Handle to; <% include convertToV8.cc.ejs -%> - return scope.Close(to); + NanReturnValue(to); <% } else { -%> - Handle toReturn = Object::New(); + Handle toReturn = NanNew(); Handle to; <% for (r in returns) { var to = returns[r]; -%> <% include convertToV8.cc.ejs -%> - toReturn->Set(String::NewSymbol("<%- to.jsName || to.name %>"), to); + toReturn->Set(NanNew("<%- to.jsName || to.name %>"), to); <% } -%> - return scope.Close(toReturn); + NanReturnValue(toReturn); <% } -%> } diff --git a/include/blob.h b/include/blob.h index 561338354..14c503678 100755 --- a/include/blob.h +++ b/include/blob.h @@ -5,8 +5,7 @@ #ifndef GITBLOB_H #define GITBLOB_H -#include -#include +#include #include #include "git2.h" @@ -28,13 +27,12 @@ class GitBlob : public ObjectWrap { GitBlob(git_blob *raw); ~GitBlob(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Oid(const Arguments& args); - static Handle Content(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle IsBinary(const Arguments& args); + static NAN_METHOD(Oid); + static NAN_METHOD(Content); + static NAN_METHOD(Size); + static NAN_METHOD(IsBinary); git_blob *raw; }; diff --git a/include/branch.h b/include/branch.h index bfbf9bcdb..02a1a71dd 100644 --- a/include/branch.h +++ b/include/branch.h @@ -5,8 +5,7 @@ #ifndef BRANCH_H #define BRANCH_H -#include -#include +#include #include #include "git2.h" @@ -28,20 +27,19 @@ class Branch : public ObjectWrap { Branch(git_branch *raw); ~Branch(); - static Handle New(const Arguments& args); - - - static Handle Create(const Arguments& args); - static Handle Delete(const Arguments& args); - static Handle Foreach(const Arguments& args); - static Handle Move(const Arguments& args); - static Handle Lookup(const Arguments& args); - static Handle Name(const Arguments& args); - static Handle Upstream(const Arguments& args); - static Handle SetUpstream(const Arguments& args); - static Handle UpstreamName(const Arguments& args); - static Handle IsHead(const Arguments& args); - static Handle RemoteName(const Arguments& args); + static NAN_METHOD(New); + + static NAN_METHOD(Create); + static NAN_METHOD(Delete); + static NAN_METHOD(Foreach); + static NAN_METHOD(Move); + static NAN_METHOD(Lookup); + static NAN_METHOD(Name); + static NAN_METHOD(Upstream); + static NAN_METHOD(SetUpstream); + static NAN_METHOD(UpstreamName); + static NAN_METHOD(IsHead); + static NAN_METHOD(RemoteName); git_branch *raw; }; diff --git a/include/clone_options.h b/include/clone_options.h index 14da5daad..6ba6b027c 100644 --- a/include/clone_options.h +++ b/include/clone_options.h @@ -5,8 +5,7 @@ #ifndef GITCLONEOPTIONS_H #define GITCLONEOPTIONS_H -#include -#include +#include #include #include "git2.h" @@ -28,8 +27,7 @@ class GitCloneOptions : public ObjectWrap { GitCloneOptions(git_clone_options *raw); ~GitCloneOptions(); - static Handle New(const Arguments& args); - + static NAN_METHOD(New); git_clone_options *raw; }; diff --git a/include/commit.h b/include/commit.h index 6f69f5889..efccd66dd 100755 --- a/include/commit.h +++ b/include/commit.h @@ -5,8 +5,7 @@ #ifndef GITCOMMIT_H #define GITCOMMIT_H -#include -#include +#include #include #include "git2.h" @@ -28,20 +27,19 @@ class GitCommit : public ObjectWrap { GitCommit(git_commit *raw); ~GitCommit(); - static Handle New(const Arguments& args); - - - static Handle Oid(const Arguments& args); - static Handle MessageEncoding(const Arguments& args); - static Handle Message(const Arguments& args); - static Handle Time(const Arguments& args); - static Handle Offset(const Arguments& args); - static Handle Committer(const Arguments& args); - static Handle Author(const Arguments& args); - static Handle TreeId(const Arguments& args); - static Handle ParentCount(const Arguments& args); - static Handle ParentId(const Arguments& args); - static Handle NthGenAncestor(const Arguments& args); + static NAN_METHOD(New); + + static NAN_METHOD(Oid); + static NAN_METHOD(MessageEncoding); + static NAN_METHOD(Message); + static NAN_METHOD(Time); + static NAN_METHOD(Offset); + static NAN_METHOD(Committer); + static NAN_METHOD(Author); + static NAN_METHOD(TreeId); + static NAN_METHOD(ParentCount); + static NAN_METHOD(ParentId); + static NAN_METHOD(NthGenAncestor); git_commit *raw; }; diff --git a/include/delta.h b/include/delta.h index e06f6283c..5c8b7315b 100644 --- a/include/delta.h +++ b/include/delta.h @@ -5,8 +5,7 @@ #ifndef GITDELTA_H #define GITDELTA_H -#include -#include +#include #include #include "git2.h" @@ -28,14 +27,13 @@ class GitDelta : public ObjectWrap { GitDelta(git_diff_delta *raw); ~GitDelta(); - static Handle New(const Arguments& args); - - static Handle OldFile(const Arguments& args); - static Handle NewFile(const Arguments& args); - static Handle Status(const Arguments& args); - static Handle Similarity(const Arguments& args); - static Handle Flags(const Arguments& args); + static NAN_METHOD(New); + static NAN_METHOD(OldFile); + static NAN_METHOD(NewFile); + static NAN_METHOD(Status); + static NAN_METHOD(Similarity); + static NAN_METHOD(Flags); git_diff_delta *raw; }; diff --git a/include/diff_file.h b/include/diff_file.h index f7f8210d0..e00eb5a6b 100644 --- a/include/diff_file.h +++ b/include/diff_file.h @@ -5,8 +5,7 @@ #ifndef GITDIFFFILE_H #define GITDIFFFILE_H -#include -#include +#include #include #include "git2.h" @@ -28,14 +27,13 @@ class GitDiffFile : public ObjectWrap { GitDiffFile(git_diff_file *raw); ~GitDiffFile(); - static Handle New(const Arguments& args); - - static Handle Oid(const Arguments& args); - static Handle Path(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle Flags(const Arguments& args); - static Handle Mode(const Arguments& args); + static NAN_METHOD(New); + static NAN_METHOD(Oid); + static NAN_METHOD(Path); + static NAN_METHOD(Size); + static NAN_METHOD(Flags); + static NAN_METHOD(Mode); git_diff_file *raw; }; diff --git a/include/diff_find_options.h b/include/diff_find_options.h index 3500d1b23..e5897cf82 100644 --- a/include/diff_find_options.h +++ b/include/diff_find_options.h @@ -5,8 +5,7 @@ #ifndef GITDIFFFINDOPTIONS_H #define GITDIFFFINDOPTIONS_H -#include -#include +#include #include #include "git2.h" @@ -28,8 +27,7 @@ class GitDiffFindOptions : public ObjectWrap { GitDiffFindOptions(git_diff_find_options *raw); ~GitDiffFindOptions(); - static Handle New(const Arguments& args); - + static NAN_METHOD(New); git_diff_find_options *raw; }; diff --git a/include/diff_list.h b/include/diff_list.h index 185a00e56..d8b4996bb 100644 --- a/include/diff_list.h +++ b/include/diff_list.h @@ -5,8 +5,7 @@ #ifndef GITDIFFLIST_H #define GITDIFFLIST_H -#include -#include +#include #include #include "git2.h" @@ -28,14 +27,13 @@ class GitDiffList : public ObjectWrap { GitDiffList(git_diff_list *raw); ~GitDiffList(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Merge(const Arguments& args); - static Handle FindSimilar(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle NumDeltasOfType(const Arguments& args); - static Handle Patch(const Arguments& args); + static NAN_METHOD(Merge); + static NAN_METHOD(FindSimilar); + static NAN_METHOD(Size); + static NAN_METHOD(NumDeltasOfType); + static NAN_METHOD(Patch); git_diff_list *raw; }; diff --git a/include/diff_options.h b/include/diff_options.h index 6dd93a0b8..79f1580be 100644 --- a/include/diff_options.h +++ b/include/diff_options.h @@ -5,8 +5,7 @@ #ifndef GITDIFFOPTIONS_H #define GITDIFFOPTIONS_H -#include -#include +#include #include #include "git2.h" @@ -28,8 +27,7 @@ class GitDiffOptions : public ObjectWrap { GitDiffOptions(git_diff_options *raw); ~GitDiffOptions(); - static Handle New(const Arguments& args); - + static NAN_METHOD(New); git_diff_options *raw; }; diff --git a/include/diff_range.h b/include/diff_range.h index bb44337b4..3d8942288 100644 --- a/include/diff_range.h +++ b/include/diff_range.h @@ -5,8 +5,7 @@ #ifndef GITDIFFRANGE_H #define GITDIFFRANGE_H -#include -#include +#include #include #include "git2.h" @@ -28,13 +27,12 @@ class GitDiffRange : public ObjectWrap { GitDiffRange(git_diff_range *raw); ~GitDiffRange(); - static Handle New(const Arguments& args); - - static Handle OldStart(const Arguments& args); - static Handle OldLines(const Arguments& args); - static Handle NewStart(const Arguments& args); - static Handle NewLines(const Arguments& args); + static NAN_METHOD(New); + static NAN_METHOD(OldStart); + static NAN_METHOD(OldLines); + static NAN_METHOD(NewStart); + static NAN_METHOD(NewLines); git_diff_range *raw; }; diff --git a/include/index.h b/include/index.h index e634d7ea0..1346136c2 100755 --- a/include/index.h +++ b/include/index.h @@ -5,8 +5,7 @@ #ifndef GITINDEX_H #define GITINDEX_H -#include -#include +#include #include #include "git2.h" @@ -28,114 +27,172 @@ class GitIndex : public ObjectWrap { GitIndex(git_index *raw); ~GitIndex(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - static Handle Open(const Arguments& args); - static void OpenWork(uv_work_t* req); - static void OpenAfterWork(uv_work_t* req); - struct OpenBaton { - uv_work_t request; int error_code; const git_error* error; git_index * out; - Persistent index_pathReference; const char * index_path; - Persistent callback; }; - static Handle Read(const Arguments& args); - static void ReadWork(uv_work_t* req); - static void ReadAfterWork(uv_work_t* req); + class OpenWorker : public NanAsyncWorker { + public: + OpenWorker( + OpenBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~OpenWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + OpenBaton *baton; + }; + static NAN_METHOD(Open); struct ReadBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent indexReference; git_index * index; - Persistent callback; }; - static Handle Write(const Arguments& args); - static void WriteWork(uv_work_t* req); - static void WriteAfterWork(uv_work_t* req); + class ReadWorker : public NanAsyncWorker { + public: + ReadWorker( + ReadBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ReadWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ReadBaton *baton; + }; + static NAN_METHOD(Read); struct WriteBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent indexReference; git_index * index; - Persistent callback; }; - static Handle ReadTree(const Arguments& args); - static void ReadTreeWork(uv_work_t* req); - static void ReadTreeAfterWork(uv_work_t* req); + class WriteWorker : public NanAsyncWorker { + public: + WriteWorker( + WriteBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~WriteWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + WriteBaton *baton; + }; + static NAN_METHOD(Write); struct ReadTreeBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent indexReference; git_index * index; - Persistent treeReference; const git_tree * tree; - Persistent callback; }; - static Handle WriteTree(const Arguments& args); - static void WriteTreeWork(uv_work_t* req); - static void WriteTreeAfterWork(uv_work_t* req); + class ReadTreeWorker : public NanAsyncWorker { + public: + ReadTreeWorker( + ReadTreeBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ReadTreeWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ReadTreeBaton *baton; + }; + static NAN_METHOD(ReadTree); struct WriteTreeBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * out; - Persistent indexReference; git_index * index; - Persistent callback; }; - static Handle Size(const Arguments& args); - static Handle Clear(const Arguments& args); - static Handle Entry(const Arguments& args); - static Handle Remove(const Arguments& args); - static Handle RemoveDirectory(const Arguments& args); - static Handle AddBypath(const Arguments& args); - static void AddBypathWork(uv_work_t* req); - static void AddBypathAfterWork(uv_work_t* req); + class WriteTreeWorker : public NanAsyncWorker { + public: + WriteTreeWorker( + WriteTreeBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~WriteTreeWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + WriteTreeBaton *baton; + }; + static NAN_METHOD(WriteTree); + static NAN_METHOD(Size); + static NAN_METHOD(Clear); + static NAN_METHOD(Entry); + static NAN_METHOD(Remove); + static NAN_METHOD(RemoveDirectory); struct AddBypathBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent indexReference; git_index * index; - Persistent pathReference; const char * path; - Persistent callback; }; - static Handle RemoveBypath(const Arguments& args); - static Handle Find(const Arguments& args); - static Handle ConflictRemove(const Arguments& args); - static Handle ConflictCleanup(const Arguments& args); - static Handle HasConflicts(const Arguments& args); - static Handle IndexToWorkdir(const Arguments& args); - static void IndexToWorkdirWork(uv_work_t* req); - static void IndexToWorkdirAfterWork(uv_work_t* req); + class AddBypathWorker : public NanAsyncWorker { + public: + AddBypathWorker( + AddBypathBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~AddBypathWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + AddBypathBaton *baton; + }; + static NAN_METHOD(AddBypath); + static NAN_METHOD(RemoveBypath); + static NAN_METHOD(Find); + static NAN_METHOD(ConflictRemove); + static NAN_METHOD(ConflictCleanup); + static NAN_METHOD(HasConflicts); struct IndexToWorkdirBaton { - uv_work_t request; int error_code; const git_error* error; git_diff_list * diff; - Persistent repoReference; git_repository * repo; - Persistent indexReference; git_index * index; - Persistent optsReference; const git_diff_options * opts; - Persistent callback; }; + class IndexToWorkdirWorker : public NanAsyncWorker { + public: + IndexToWorkdirWorker( + IndexToWorkdirBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~IndexToWorkdirWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + IndexToWorkdirBaton *baton; + }; + static NAN_METHOD(IndexToWorkdir); git_index *raw; }; diff --git a/include/index_entry.h b/include/index_entry.h index 7bf5fc6a8..47f6ef156 100644 --- a/include/index_entry.h +++ b/include/index_entry.h @@ -5,8 +5,7 @@ #ifndef GITINDEXENTRY_H #define GITINDEXENTRY_H -#include -#include +#include #include #include "git2.h" @@ -28,21 +27,20 @@ class GitIndexEntry : public ObjectWrap { GitIndexEntry(git_index_entry *raw); ~GitIndexEntry(); - static Handle New(const Arguments& args); - - static Handle Ctime(const Arguments& args); - static Handle Mtime(const Arguments& args); - static Handle Dev(const Arguments& args); - static Handle Ino(const Arguments& args); - static Handle Mode(const Arguments& args); - static Handle Uid(const Arguments& args); - static Handle gid(const Arguments& args); - static Handle FileSize(const Arguments& args); - static Handle Oid(const Arguments& args); - static Handle Flags(const Arguments& args); - static Handle FlagsExtended(const Arguments& args); - static Handle Path(const Arguments& args); - + static NAN_METHOD(New); + + static NAN_METHOD(Ctime); + static NAN_METHOD(Mtime); + static NAN_METHOD(Dev); + static NAN_METHOD(Ino); + static NAN_METHOD(Mode); + static NAN_METHOD(Uid); + static NAN_METHOD(gid); + static NAN_METHOD(FileSize); + static NAN_METHOD(Oid); + static NAN_METHOD(Flags); + static NAN_METHOD(FlagsExtended); + static NAN_METHOD(Path); git_index_entry *raw; }; diff --git a/include/index_time.h b/include/index_time.h index 765ce6cc7..d60a7fce3 100644 --- a/include/index_time.h +++ b/include/index_time.h @@ -5,8 +5,7 @@ #ifndef GITINDEXTIME_H #define GITINDEXTIME_H -#include -#include +#include #include #include "git2.h" @@ -28,11 +27,10 @@ class GitIndexTime : public ObjectWrap { GitIndexTime(git_index_time *raw); ~GitIndexTime(); - static Handle New(const Arguments& args); - - static Handle Seconds(const Arguments& args); - static Handle Nanoseconds(const Arguments& args); + static NAN_METHOD(New); + static NAN_METHOD(Seconds); + static NAN_METHOD(Nanoseconds); git_index_time *raw; }; diff --git a/include/object.h b/include/object.h index 6ab9d3537..69b4c1ecb 100644 --- a/include/object.h +++ b/include/object.h @@ -5,8 +5,7 @@ #ifndef GITOBJECT_H #define GITOBJECT_H -#include -#include +#include #include #include "git2.h" @@ -28,26 +27,33 @@ class GitObject : public ObjectWrap { GitObject(git_object *raw); ~GitObject(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Oid(const Arguments& args); - static Handle Type(const Arguments& args); - static Handle Peel(const Arguments& args); - static void PeelWork(uv_work_t* req); - static void PeelAfterWork(uv_work_t* req); + static NAN_METHOD(Oid); + static NAN_METHOD(Type); struct PeelBaton { - uv_work_t request; int error_code; const git_error* error; git_object * peeled; - Persistent objectReference; const git_object * object; - Persistent target_typeReference; git_otype target_type; - Persistent callback; }; + class PeelWorker : public NanAsyncWorker { + public: + PeelWorker( + PeelBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~PeelWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + PeelBaton *baton; + }; + static NAN_METHOD(Peel); git_object *raw; }; diff --git a/include/odb.h b/include/odb.h index 6ed9913d9..7fb77bbba 100644 --- a/include/odb.h +++ b/include/odb.h @@ -5,8 +5,7 @@ #ifndef GITODB_H #define GITODB_H -#include -#include +#include #include #include "git2.h" @@ -28,52 +27,65 @@ class GitOdb : public ObjectWrap { GitOdb(git_odb *raw); ~GitOdb(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Create(const Arguments& args); - static Handle Open(const Arguments& args); - static Handle AddDiskAlternate(const Arguments& args); - static Handle Read(const Arguments& args); - static void ReadWork(uv_work_t* req); - static void ReadAfterWork(uv_work_t* req); + static NAN_METHOD(Create); + static NAN_METHOD(Open); + static NAN_METHOD(AddDiskAlternate); struct ReadBaton { - uv_work_t request; int error_code; const git_error* error; git_odb_object * out; - Persistent dbReference; git_odb * db; - Persistent idReference; const git_oid * id; - Persistent callback; }; - static Handle ReadPrefix(const Arguments& args); - static Handle ReadHeader(const Arguments& args); - static Handle Exists(const Arguments& args); - static Handle Refresh(const Arguments& args); - static Handle Write(const Arguments& args); - static void WriteWork(uv_work_t* req); - static void WriteAfterWork(uv_work_t* req); + class ReadWorker : public NanAsyncWorker { + public: + ReadWorker( + ReadBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ReadWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ReadBaton *baton; + }; + static NAN_METHOD(Read); + static NAN_METHOD(ReadPrefix); + static NAN_METHOD(ReadHeader); + static NAN_METHOD(Exists); + static NAN_METHOD(Refresh); struct WriteBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * out; - Persistent odbReference; git_odb * odb; - Persistent dataReference; const void * data; - Persistent lenReference; size_t len; - Persistent typeReference; git_otype type; - Persistent callback; }; - static Handle Hash(const Arguments& args); - static Handle Hashfile(const Arguments& args); + class WriteWorker : public NanAsyncWorker { + public: + WriteWorker( + WriteBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~WriteWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + WriteBaton *baton; + }; + static NAN_METHOD(Write); + static NAN_METHOD(Hash); + static NAN_METHOD(Hashfile); git_odb *raw; }; diff --git a/include/odb_object.h b/include/odb_object.h index 7938dfa49..f32508592 100644 --- a/include/odb_object.h +++ b/include/odb_object.h @@ -5,8 +5,7 @@ #ifndef GITODBOBJECT_H #define GITODBOBJECT_H -#include -#include +#include #include #include "git2.h" @@ -28,13 +27,12 @@ class GitOdbObject : public ObjectWrap { GitOdbObject(git_odb_object *raw); ~GitOdbObject(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Data(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle Type(const Arguments& args); - static Handle Oid(const Arguments& args); + static NAN_METHOD(Data); + static NAN_METHOD(Size); + static NAN_METHOD(Type); + static NAN_METHOD(Oid); git_odb_object *raw; }; diff --git a/include/oid.h b/include/oid.h index 2ce3a9e5c..4c0e0986e 100755 --- a/include/oid.h +++ b/include/oid.h @@ -5,8 +5,7 @@ #ifndef GITOID_H #define GITOID_H -#include -#include +#include #include #include "git2.h" @@ -28,11 +27,10 @@ class GitOid : public ObjectWrap { GitOid(git_oid *raw); ~GitOid(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle FromString(const Arguments& args); - static Handle Sha(const Arguments& args); + static NAN_METHOD(FromString); + static NAN_METHOD(Sha); git_oid *raw; }; diff --git a/include/patch.h b/include/patch.h index 7a4d408ff..ddd6de050 100644 --- a/include/patch.h +++ b/include/patch.h @@ -5,8 +5,7 @@ #ifndef GITPATCH_H #define GITPATCH_H -#include -#include +#include #include #include "git2.h" @@ -28,16 +27,15 @@ class GitPatch : public ObjectWrap { GitPatch(git_diff_patch *raw); ~GitPatch(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Delta(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle Stats(const Arguments& args); - static Handle Hunk(const Arguments& args); - static Handle Lines(const Arguments& args); - static Handle Line(const Arguments& args); - static Handle ToString(const Arguments& args); + static NAN_METHOD(Delta); + static NAN_METHOD(Size); + static NAN_METHOD(Stats); + static NAN_METHOD(Hunk); + static NAN_METHOD(Lines); + static NAN_METHOD(Line); + static NAN_METHOD(ToString); git_diff_patch *raw; }; diff --git a/include/refdb.h b/include/refdb.h index 51355028f..8f928e208 100644 --- a/include/refdb.h +++ b/include/refdb.h @@ -5,8 +5,7 @@ #ifndef GITREFDB_H #define GITREFDB_H -#include -#include +#include #include #include "git2.h" @@ -28,8 +27,7 @@ class GitRefDb : public ObjectWrap { GitRefDb(git_refdb *raw); ~GitRefDb(); - static Handle New(const Arguments& args); - + static NAN_METHOD(New); git_refdb *raw; }; diff --git a/include/reference.h b/include/reference.h index ae7d18ad4..13eaa5107 100644 --- a/include/reference.h +++ b/include/reference.h @@ -5,8 +5,7 @@ #ifndef GITREFERENCE_H #define GITREFERENCE_H -#include -#include +#include #include #include "git2.h" @@ -28,76 +27,108 @@ class GitReference : public ObjectWrap { GitReference(git_reference *raw); ~GitReference(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - static Handle OidForName(const Arguments& args); - static void OidForNameWork(uv_work_t* req); - static void OidForNameAfterWork(uv_work_t* req); - struct OidForNameBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * out; - Persistent repoReference; git_repository * repo; - Persistent nameReference; const char * name; - Persistent callback; }; - static Handle Target(const Arguments& args); - static Handle SymbolicTarget(const Arguments& args); - static Handle Type(const Arguments& args); - static Handle Name(const Arguments& args); - static Handle Resolve(const Arguments& args); - static void ResolveWork(uv_work_t* req); - static void ResolveAfterWork(uv_work_t* req); + class OidForNameWorker : public NanAsyncWorker { + public: + OidForNameWorker( + OidForNameBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~OidForNameWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + OidForNameBaton *baton; + }; + static NAN_METHOD(OidForName); + static NAN_METHOD(Target); + static NAN_METHOD(SymbolicTarget); + static NAN_METHOD(Type); + static NAN_METHOD(Name); struct ResolveBaton { - uv_work_t request; int error_code; const git_error* error; git_reference * out; - Persistent refReference; const git_reference * ref; - Persistent callback; }; - static Handle SetSymbolicTarget(const Arguments& args); - static Handle setTarget(const Arguments& args); - static Handle Rename(const Arguments& args); - static void RenameWork(uv_work_t* req); - static void RenameAfterWork(uv_work_t* req); + class ResolveWorker : public NanAsyncWorker { + public: + ResolveWorker( + ResolveBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ResolveWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ResolveBaton *baton; + }; + static NAN_METHOD(Resolve); + static NAN_METHOD(SetSymbolicTarget); + static NAN_METHOD(setTarget); struct RenameBaton { - uv_work_t request; int error_code; const git_error* error; git_reference * out; - Persistent refReference; git_reference * ref; - Persistent new_nameReference; const char * new_name; - Persistent forceReference; int force; - Persistent callback; }; - static Handle Delete(const Arguments& args); - static void DeleteWork(uv_work_t* req); - static void DeleteAfterWork(uv_work_t* req); + class RenameWorker : public NanAsyncWorker { + public: + RenameWorker( + RenameBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~RenameWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + RenameBaton *baton; + }; + static NAN_METHOD(Rename); struct DeleteBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent refReference; git_reference * ref; - Persistent callback; }; - static Handle IsBranch(const Arguments& args); - static Handle IsRemote(const Arguments& args); - static Handle Peel(const Arguments& args); - static Handle IsValidName(const Arguments& args); + class DeleteWorker : public NanAsyncWorker { + public: + DeleteWorker( + DeleteBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DeleteWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DeleteBaton *baton; + }; + static NAN_METHOD(Delete); + static NAN_METHOD(IsBranch); + static NAN_METHOD(IsRemote); + static NAN_METHOD(Peel); + static NAN_METHOD(IsValidName); git_reference *raw; }; diff --git a/include/remote.h b/include/remote.h index 81fd1ac68..73af9487c 100644 --- a/include/remote.h +++ b/include/remote.h @@ -5,8 +5,7 @@ #ifndef GITREMOTE_H #define GITREMOTE_H -#include -#include +#include #include #include "git2.h" @@ -28,65 +27,88 @@ class GitRemote : public ObjectWrap { GitRemote(git_remote *raw); ~GitRemote(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Name(const Arguments& args); - static Handle Url(const Arguments& args); - static Handle PushUrl(const Arguments& args); - static Handle SetUrl(const Arguments& args); - static Handle SetPushUrl(const Arguments& args); - static Handle Connect(const Arguments& args); - static void ConnectWork(uv_work_t* req); - static void ConnectAfterWork(uv_work_t* req); + static NAN_METHOD(Name); + static NAN_METHOD(Url); + static NAN_METHOD(PushUrl); + static NAN_METHOD(SetUrl); + static NAN_METHOD(SetPushUrl); struct ConnectBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent remoteReference; git_remote * remote; - Persistent directionReference; git_direction direction; - Persistent callback; }; - static Handle Download(const Arguments& args); - static void DownloadWork(uv_work_t* req); - static void DownloadAfterWork(uv_work_t* req); + class ConnectWorker : public NanAsyncWorker { + public: + ConnectWorker( + ConnectBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ConnectWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ConnectBaton *baton; + }; + static NAN_METHOD(Connect); struct DownloadBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent remoteReference; git_remote * remote; - Persistent progress_cbReference; git_transfer_progress_callback progress_cb; - Persistent payloadReference; void * payload; - Persistent callback; }; - static Handle Connected(const Arguments& args); - static Handle Stop(const Arguments& args); - static Handle Disconnect(const Arguments& args); - static void DisconnectWork(uv_work_t* req); - static void DisconnectAfterWork(uv_work_t* req); + class DownloadWorker : public NanAsyncWorker { + public: + DownloadWorker( + DownloadBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DownloadWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DownloadBaton *baton; + }; + static NAN_METHOD(Download); + static NAN_METHOD(Connected); + static NAN_METHOD(Stop); struct DisconnectBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent remoteReference; git_remote * remote; - Persistent callback; }; - static Handle UpdateTips(const Arguments& args); - static Handle ValidUrl(const Arguments& args); - static Handle SupportedUrl(const Arguments& args); - static Handle CheckCert(const Arguments& args); - static Handle UpdateFetchhead(const Arguments& args); - static Handle SetUpdateFetchhead(const Arguments& args); - static Handle IsValidName(const Arguments& args); + class DisconnectWorker : public NanAsyncWorker { + public: + DisconnectWorker( + DisconnectBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DisconnectWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DisconnectBaton *baton; + }; + static NAN_METHOD(Disconnect); + static NAN_METHOD(UpdateTips); + static NAN_METHOD(ValidUrl); + static NAN_METHOD(SupportedUrl); + static NAN_METHOD(CheckCert); + static NAN_METHOD(UpdateFetchhead); + static NAN_METHOD(SetUpdateFetchhead); + static NAN_METHOD(IsValidName); git_remote *raw; }; diff --git a/include/repo.h b/include/repo.h index 8f10f3427..a5a71e400 100755 --- a/include/repo.h +++ b/include/repo.h @@ -5,8 +5,7 @@ #ifndef GITREPO_H #define GITREPO_H -#include -#include +#include #include #include "git2.h" @@ -28,342 +27,488 @@ class GitRepo : public ObjectWrap { GitRepo(git_repository *raw); ~GitRepo(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - static Handle Open(const Arguments& args); - static void OpenWork(uv_work_t* req); - static void OpenAfterWork(uv_work_t* req); - struct OpenBaton { - uv_work_t request; int error_code; const git_error* error; git_repository * out; - Persistent pathReference; const char * path; - Persistent callback; }; - static Handle Init(const Arguments& args); - static void InitWork(uv_work_t* req); - static void InitAfterWork(uv_work_t* req); + class OpenWorker : public NanAsyncWorker { + public: + OpenWorker( + OpenBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~OpenWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + OpenBaton *baton; + }; + static NAN_METHOD(Open); struct InitBaton { - uv_work_t request; int error_code; const git_error* error; git_repository * out; - Persistent pathReference; const char * path; - Persistent is_bareReference; unsigned is_bare; - Persistent callback; }; - static Handle Path(const Arguments& args); - static Handle Workdir(const Arguments& args); - static Handle Odb(const Arguments& args); - static Handle openIndex(const Arguments& args); - static void openIndexWork(uv_work_t* req); - static void openIndexAfterWork(uv_work_t* req); + class InitWorker : public NanAsyncWorker { + public: + InitWorker( + InitBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~InitWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + InitBaton *baton; + }; + static NAN_METHOD(Init); + static NAN_METHOD(Path); + static NAN_METHOD(Workdir); + static NAN_METHOD(Odb); struct openIndexBaton { - uv_work_t request; int error_code; const git_error* error; git_index * out; - Persistent repoReference; git_repository * repo; - Persistent callback; }; - static Handle GetBlob(const Arguments& args); - static void GetBlobWork(uv_work_t* req); - static void GetBlobAfterWork(uv_work_t* req); + class openIndexWorker : public NanAsyncWorker { + public: + openIndexWorker( + openIndexBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~openIndexWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + openIndexBaton *baton; + }; + static NAN_METHOD(openIndex); struct GetBlobBaton { - uv_work_t request; int error_code; const git_error* error; git_blob * blob; - Persistent repoReference; git_repository * repo; - Persistent idReference; const git_oid * id; - Persistent callback; }; - static Handle GetCommit(const Arguments& args); - static void GetCommitWork(uv_work_t* req); - static void GetCommitAfterWork(uv_work_t* req); + class GetBlobWorker : public NanAsyncWorker { + public: + GetBlobWorker( + GetBlobBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetBlobWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetBlobBaton *baton; + }; + static NAN_METHOD(GetBlob); struct GetCommitBaton { - uv_work_t request; int error_code; const git_error* error; git_commit * commit; - Persistent repoReference; git_repository * repo; - Persistent idReference; const git_oid * id; - Persistent callback; }; - static Handle CreateCommit(const Arguments& args); - static void CreateCommitWork(uv_work_t* req); - static void CreateCommitAfterWork(uv_work_t* req); + class GetCommitWorker : public NanAsyncWorker { + public: + GetCommitWorker( + GetCommitBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetCommitWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetCommitBaton *baton; + }; + static NAN_METHOD(GetCommit); struct CreateCommitBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * id; - Persistent repoReference; git_repository * repo; - Persistent update_refReference; const char * update_ref; - Persistent authorReference; const git_signature * author; - Persistent committerReference; const git_signature * committer; - Persistent message_encodingReference; const char * message_encoding; - Persistent messageReference; const char * message; - Persistent treeReference; const git_tree * tree; - Persistent parent_countReference; int parent_count; - Persistent parentsReference; const git_commit ** parents; - Persistent callback; }; - static Handle GetObject(const Arguments& args); - static void GetObjectWork(uv_work_t* req); - static void GetObjectAfterWork(uv_work_t* req); + class CreateCommitWorker : public NanAsyncWorker { + public: + CreateCommitWorker( + CreateCommitBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~CreateCommitWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + CreateCommitBaton *baton; + }; + static NAN_METHOD(CreateCommit); struct GetObjectBaton { - uv_work_t request; int error_code; const git_error* error; git_object * object; - Persistent repoReference; git_repository * repo; - Persistent idReference; const git_oid * id; - Persistent typeReference; git_otype type; - Persistent callback; }; - static Handle GetReference(const Arguments& args); - static void GetReferenceWork(uv_work_t* req); - static void GetReferenceAfterWork(uv_work_t* req); + class GetObjectWorker : public NanAsyncWorker { + public: + GetObjectWorker( + GetObjectBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetObjectWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetObjectBaton *baton; + }; + static NAN_METHOD(GetObject); struct GetReferenceBaton { - uv_work_t request; int error_code; const git_error* error; git_reference * out; - Persistent repoReference; git_repository * repo; - Persistent nameReference; const char * name; - Persistent callback; }; - static Handle CreateSymbolicReference(const Arguments& args); - static Handle CreateReference(const Arguments& args); - static Handle AddRemote(const Arguments& args); - static void AddRemoteWork(uv_work_t* req); - static void AddRemoteAfterWork(uv_work_t* req); + class GetReferenceWorker : public NanAsyncWorker { + public: + GetReferenceWorker( + GetReferenceBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetReferenceWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetReferenceBaton *baton; + }; + static NAN_METHOD(GetReference); + static NAN_METHOD(CreateSymbolicReference); + static NAN_METHOD(CreateReference); struct AddRemoteBaton { - uv_work_t request; int error_code; const git_error* error; git_remote * out; - Persistent repoReference; git_repository * repo; - Persistent nameReference; const char * name; - Persistent urlReference; const char * url; - Persistent callback; }; - static Handle CreateRevWalk(const Arguments& args); - static Handle GetSubmodule(const Arguments& args); - static Handle AddSubmodule(const Arguments& args); - static Handle GetTag(const Arguments& args); - static void GetTagWork(uv_work_t* req); - static void GetTagAfterWork(uv_work_t* req); + class AddRemoteWorker : public NanAsyncWorker { + public: + AddRemoteWorker( + AddRemoteBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~AddRemoteWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + AddRemoteBaton *baton; + }; + static NAN_METHOD(AddRemote); + static NAN_METHOD(CreateRevWalk); + static NAN_METHOD(GetSubmodule); + static NAN_METHOD(AddSubmodule); struct GetTagBaton { - uv_work_t request; int error_code; const git_error* error; git_tag * out; - Persistent repoReference; git_repository * repo; - Persistent idReference; const git_oid * id; - Persistent callback; }; - static Handle CreateTag(const Arguments& args); - static void CreateTagWork(uv_work_t* req); - static void CreateTagAfterWork(uv_work_t* req); + class GetTagWorker : public NanAsyncWorker { + public: + GetTagWorker( + GetTagBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetTagWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetTagBaton *baton; + }; + static NAN_METHOD(GetTag); struct CreateTagBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * oid; - Persistent repoReference; git_repository * repo; - Persistent tag_nameReference; const char * tag_name; - Persistent targetReference; const git_object * target; - Persistent taggerReference; const git_signature * tagger; - Persistent messageReference; const char * message; - Persistent forceReference; int force; - Persistent callback; }; - static Handle CreateLightweightTag(const Arguments& args); - static void CreateLightweightTagWork(uv_work_t* req); - static void CreateLightweightTagAfterWork(uv_work_t* req); + class CreateTagWorker : public NanAsyncWorker { + public: + CreateTagWorker( + CreateTagBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~CreateTagWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + CreateTagBaton *baton; + }; + static NAN_METHOD(CreateTag); struct CreateLightweightTagBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * oid; - Persistent repoReference; git_repository * repo; - Persistent tag_nameReference; const char * tag_name; - Persistent targetReference; const git_object * target; - Persistent forceReference; int force; - Persistent callback; }; - static Handle GetTree(const Arguments& args); - static void GetTreeWork(uv_work_t* req); - static void GetTreeAfterWork(uv_work_t* req); + class CreateLightweightTagWorker : public NanAsyncWorker { + public: + CreateLightweightTagWorker( + CreateLightweightTagBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~CreateLightweightTagWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + CreateLightweightTagBaton *baton; + }; + static NAN_METHOD(CreateLightweightTag); struct GetTreeBaton { - uv_work_t request; int error_code; const git_error* error; git_tree * out; - Persistent repoReference; git_repository * repo; - Persistent idReference; const git_oid * id; - Persistent callback; }; - static Handle ReloadSubmodules(const Arguments& args); - static void ReloadSubmodulesWork(uv_work_t* req); - static void ReloadSubmodulesAfterWork(uv_work_t* req); + class GetTreeWorker : public NanAsyncWorker { + public: + GetTreeWorker( + GetTreeBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetTreeWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetTreeBaton *baton; + }; + static NAN_METHOD(GetTree); struct ReloadSubmodulesBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent repoReference; git_repository * repo; - Persistent callback; }; - static Handle Delete(const Arguments& args); - static void DeleteWork(uv_work_t* req); - static void DeleteAfterWork(uv_work_t* req); + class ReloadSubmodulesWorker : public NanAsyncWorker { + public: + ReloadSubmodulesWorker( + ReloadSubmodulesBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ReloadSubmodulesWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ReloadSubmodulesBaton *baton; + }; + static NAN_METHOD(ReloadSubmodules); struct DeleteBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent repoReference; git_repository * repo; - Persistent tag_nameReference; const char * tag_name; - Persistent callback; }; - static Handle GetReferences(const Arguments& args); - static void GetReferencesWork(uv_work_t* req); - static void GetReferencesAfterWork(uv_work_t* req); + class DeleteWorker : public NanAsyncWorker { + public: + DeleteWorker( + DeleteBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DeleteWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DeleteBaton *baton; + }; + static NAN_METHOD(Delete); struct GetReferencesBaton { - uv_work_t request; int error_code; const git_error* error; git_strarray * array; - Persistent repoReference; git_repository * repo; - Persistent list_flagsReference; unsigned int list_flags; - Persistent callback; }; - static Handle CreateBlobFromBuffer(const Arguments& args); - static void CreateBlobFromBufferWork(uv_work_t* req); - static void CreateBlobFromBufferAfterWork(uv_work_t* req); + class GetReferencesWorker : public NanAsyncWorker { + public: + GetReferencesWorker( + GetReferencesBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetReferencesWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetReferencesBaton *baton; + }; + static NAN_METHOD(GetReferences); struct CreateBlobFromBufferBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * oid; - Persistent repoReference; git_repository * repo; - Persistent bufferReference; const void * buffer; - Persistent lenReference; size_t len; - Persistent callback; }; - static Handle CreateBlobFromFile(const Arguments& args); - static void CreateBlobFromFileWork(uv_work_t* req); - static void CreateBlobFromFileAfterWork(uv_work_t* req); + class CreateBlobFromBufferWorker : public NanAsyncWorker { + public: + CreateBlobFromBufferWorker( + CreateBlobFromBufferBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~CreateBlobFromBufferWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + CreateBlobFromBufferBaton *baton; + }; + static NAN_METHOD(CreateBlobFromBuffer); struct CreateBlobFromFileBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * id; - Persistent repoReference; git_repository * repo; - Persistent pathReference; const char * path; - Persistent callback; }; - static Handle GetRemotes(const Arguments& args); - static void GetRemotesWork(uv_work_t* req); - static void GetRemotesAfterWork(uv_work_t* req); + class CreateBlobFromFileWorker : public NanAsyncWorker { + public: + CreateBlobFromFileWorker( + CreateBlobFromFileBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~CreateBlobFromFileWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + CreateBlobFromFileBaton *baton; + }; + static NAN_METHOD(CreateBlobFromFile); struct GetRemotesBaton { - uv_work_t request; int error_code; const git_error* error; git_strarray * out; - Persistent repoReference; git_repository * repo; - Persistent callback; }; - static Handle Clone(const Arguments& args); - static void CloneWork(uv_work_t* req); - static void CloneAfterWork(uv_work_t* req); + class GetRemotesWorker : public NanAsyncWorker { + public: + GetRemotesWorker( + GetRemotesBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetRemotesWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetRemotesBaton *baton; + }; + static NAN_METHOD(GetRemotes); struct CloneBaton { - uv_work_t request; int error_code; const git_error* error; git_repository * out; - Persistent urlReference; const char * url; - Persistent local_pathReference; const char * local_path; - Persistent optionsReference; const git_clone_options * options; - Persistent callback; }; - static Handle GetRemote(const Arguments& args); + class CloneWorker : public NanAsyncWorker { + public: + CloneWorker( + CloneBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~CloneWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + CloneBaton *baton; + }; + static NAN_METHOD(Clone); + static NAN_METHOD(GetRemote); git_repository *raw; }; diff --git a/include/revwalk.h b/include/revwalk.h index c2096cc61..29866e43f 100755 --- a/include/revwalk.h +++ b/include/revwalk.h @@ -5,8 +5,7 @@ #ifndef GITREVWALK_H #define GITREVWALK_H -#include -#include +#include #include #include "git2.h" @@ -28,132 +27,206 @@ class GitRevWalk : public ObjectWrap { GitRevWalk(git_revwalk *raw); ~GitRevWalk(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Reset(const Arguments& args); - static Handle Push(const Arguments& args); - static void PushWork(uv_work_t* req); - static void PushAfterWork(uv_work_t* req); + static NAN_METHOD(Reset); struct PushBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent idReference; const git_oid * id; - Persistent callback; }; - static Handle PushGlob(const Arguments& args); - static void PushGlobWork(uv_work_t* req); - static void PushGlobAfterWork(uv_work_t* req); + class PushWorker : public NanAsyncWorker { + public: + PushWorker( + PushBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~PushWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + PushBaton *baton; + }; + static NAN_METHOD(Push); struct PushGlobBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent globReference; const char * glob; - Persistent callback; }; - static Handle PushHead(const Arguments& args); - static void PushHeadWork(uv_work_t* req); - static void PushHeadAfterWork(uv_work_t* req); + class PushGlobWorker : public NanAsyncWorker { + public: + PushGlobWorker( + PushGlobBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~PushGlobWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + PushGlobBaton *baton; + }; + static NAN_METHOD(PushGlob); struct PushHeadBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent callback; }; - static Handle Hide(const Arguments& args); - static void HideWork(uv_work_t* req); - static void HideAfterWork(uv_work_t* req); + class PushHeadWorker : public NanAsyncWorker { + public: + PushHeadWorker( + PushHeadBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~PushHeadWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + PushHeadBaton *baton; + }; + static NAN_METHOD(PushHead); struct HideBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent commit_idReference; const git_oid * commit_id; - Persistent callback; }; - static Handle HideGlob(const Arguments& args); - static void HideGlobWork(uv_work_t* req); - static void HideGlobAfterWork(uv_work_t* req); + class HideWorker : public NanAsyncWorker { + public: + HideWorker( + HideBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~HideWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + HideBaton *baton; + }; + static NAN_METHOD(Hide); struct HideGlobBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent globReference; const char * glob; - Persistent callback; }; - static Handle HideHead(const Arguments& args); - static void HideHeadWork(uv_work_t* req); - static void HideHeadAfterWork(uv_work_t* req); + class HideGlobWorker : public NanAsyncWorker { + public: + HideGlobWorker( + HideGlobBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~HideGlobWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + HideGlobBaton *baton; + }; + static NAN_METHOD(HideGlob); struct HideHeadBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent callback; }; - static Handle PushRef(const Arguments& args); - static void PushRefWork(uv_work_t* req); - static void PushRefAfterWork(uv_work_t* req); + class HideHeadWorker : public NanAsyncWorker { + public: + HideHeadWorker( + HideHeadBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~HideHeadWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + HideHeadBaton *baton; + }; + static NAN_METHOD(HideHead); struct PushRefBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent refnameReference; const char * refname; - Persistent callback; }; - static Handle HideRef(const Arguments& args); - static void HideRefWork(uv_work_t* req); - static void HideRefAfterWork(uv_work_t* req); + class PushRefWorker : public NanAsyncWorker { + public: + PushRefWorker( + PushRefBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~PushRefWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + PushRefBaton *baton; + }; + static NAN_METHOD(PushRef); struct HideRefBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent walkReference; git_revwalk * walk; - Persistent refnameReference; const char * refname; - Persistent callback; }; - static Handle Next(const Arguments& args); - static void NextWork(uv_work_t* req); - static void NextAfterWork(uv_work_t* req); + class HideRefWorker : public NanAsyncWorker { + public: + HideRefWorker( + HideRefBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~HideRefWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + HideRefBaton *baton; + }; + static NAN_METHOD(HideRef); struct NextBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * out; - Persistent walkReference; git_revwalk * walk; - Persistent callback; }; - static Handle Sorting(const Arguments& args); + class NextWorker : public NanAsyncWorker { + public: + NextWorker( + NextBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~NextWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + NextBaton *baton; + }; + static NAN_METHOD(Next); + static NAN_METHOD(Sorting); git_revwalk *raw; }; diff --git a/include/signature.h b/include/signature.h index 14d542c82..e6e3c58c7 100755 --- a/include/signature.h +++ b/include/signature.h @@ -5,8 +5,7 @@ #ifndef GITSIGNATURE_H #define GITSIGNATURE_H -#include -#include +#include #include #include "git2.h" @@ -28,14 +27,13 @@ class GitSignature : public ObjectWrap { GitSignature(git_signature *raw); ~GitSignature(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - static Handle Name(const Arguments& args); - static Handle Email(const Arguments& args); - static Handle Time(const Arguments& args); - - static Handle Create(const Arguments& args); - static Handle Now(const Arguments& args); + static NAN_METHOD(Name); + static NAN_METHOD(Email); + static NAN_METHOD(Time); + static NAN_METHOD(Create); + static NAN_METHOD(Now); git_signature *raw; }; diff --git a/include/submodule.h b/include/submodule.h index f80d8ee3d..dfd25ed3e 100644 --- a/include/submodule.h +++ b/include/submodule.h @@ -5,8 +5,7 @@ #ifndef GITSUBMODULE_H #define GITSUBMODULE_H -#include -#include +#include #include #include "git2.h" @@ -28,118 +27,186 @@ class GitSubmodule : public ObjectWrap { GitSubmodule(git_submodule *raw); ~GitSubmodule(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - static Handle AddFinalize(const Arguments& args); - static void AddFinalizeWork(uv_work_t* req); - static void AddFinalizeAfterWork(uv_work_t* req); - struct AddFinalizeBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent submoduleReference; git_submodule * submodule; - Persistent callback; }; - static Handle AddToIndex(const Arguments& args); - static void AddToIndexWork(uv_work_t* req); - static void AddToIndexAfterWork(uv_work_t* req); + class AddFinalizeWorker : public NanAsyncWorker { + public: + AddFinalizeWorker( + AddFinalizeBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~AddFinalizeWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + AddFinalizeBaton *baton; + }; + static NAN_METHOD(AddFinalize); struct AddToIndexBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent submoduleReference; git_submodule * submodule; - Persistent write_indexReference; int write_index; - Persistent callback; }; - static Handle Save(const Arguments& args); - static void SaveWork(uv_work_t* req); - static void SaveAfterWork(uv_work_t* req); + class AddToIndexWorker : public NanAsyncWorker { + public: + AddToIndexWorker( + AddToIndexBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~AddToIndexWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + AddToIndexBaton *baton; + }; + static NAN_METHOD(AddToIndex); struct SaveBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent submoduleReference; git_submodule * submodule; - Persistent callback; - }; - static Handle Name(const Arguments& args); - static Handle Path(const Arguments& args); - static Handle Url(const Arguments& args); - static Handle SetUrl(const Arguments& args); - static Handle IndexId(const Arguments& args); - static Handle HeadId(const Arguments& args); - static Handle Init(const Arguments& args); - static void InitWork(uv_work_t* req); - static void InitAfterWork(uv_work_t* req); + }; + class SaveWorker : public NanAsyncWorker { + public: + SaveWorker( + SaveBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~SaveWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + SaveBaton *baton; + }; + static NAN_METHOD(Save); + static NAN_METHOD(Name); + static NAN_METHOD(Path); + static NAN_METHOD(Url); + static NAN_METHOD(SetUrl); + static NAN_METHOD(IndexId); + static NAN_METHOD(HeadId); struct InitBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent submoduleReference; git_submodule * submodule; - Persistent overwriteReference; int overwrite; - Persistent callback; }; - static Handle Sync(const Arguments& args); - static void SyncWork(uv_work_t* req); - static void SyncAfterWork(uv_work_t* req); + class InitWorker : public NanAsyncWorker { + public: + InitWorker( + InitBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~InitWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + InitBaton *baton; + }; + static NAN_METHOD(Init); struct SyncBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent submoduleReference; git_submodule * submodule; - Persistent callback; }; - static Handle Open(const Arguments& args); - static void OpenWork(uv_work_t* req); - static void OpenAfterWork(uv_work_t* req); + class SyncWorker : public NanAsyncWorker { + public: + SyncWorker( + SyncBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~SyncWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + SyncBaton *baton; + }; + static NAN_METHOD(Sync); struct OpenBaton { - uv_work_t request; int error_code; const git_error* error; git_repository * repo; - Persistent submoduleReference; git_submodule * submodule; - Persistent callback; }; - static Handle Reload(const Arguments& args); - static void ReloadWork(uv_work_t* req); - static void ReloadAfterWork(uv_work_t* req); + class OpenWorker : public NanAsyncWorker { + public: + OpenWorker( + OpenBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~OpenWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + OpenBaton *baton; + }; + static NAN_METHOD(Open); struct ReloadBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent submoduleReference; git_submodule * submodule; - Persistent callback; }; - static Handle Status(const Arguments& args); - static void StatusWork(uv_work_t* req); - static void StatusAfterWork(uv_work_t* req); + class ReloadWorker : public NanAsyncWorker { + public: + ReloadWorker( + ReloadBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~ReloadWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + ReloadBaton *baton; + }; + static NAN_METHOD(Reload); struct StatusBaton { - uv_work_t request; int error_code; const git_error* error; - Persistent statusReference; unsigned int * status; - Persistent submoduleReference; git_submodule * submodule; - Persistent callback; }; + class StatusWorker : public NanAsyncWorker { + public: + StatusWorker( + StatusBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~StatusWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + StatusBaton *baton; + }; + static NAN_METHOD(Status); git_submodule *raw; }; diff --git a/include/tag.h b/include/tag.h index f89ded8b1..abbada0ed 100755 --- a/include/tag.h +++ b/include/tag.h @@ -5,8 +5,7 @@ #ifndef GITTAG_H #define GITTAG_H -#include -#include +#include #include #include "git2.h" @@ -28,29 +27,37 @@ class GitTag : public ObjectWrap { GitTag(git_tag *raw); ~GitTag(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Oid(const Arguments& args); - static Handle GetTarget(const Arguments& args); - static void GetTargetWork(uv_work_t* req); - static void GetTargetAfterWork(uv_work_t* req); + static NAN_METHOD(Oid); struct GetTargetBaton { - uv_work_t request; int error_code; const git_error* error; git_object * target_out; - Persistent tagReference; const git_tag * tag; - Persistent callback; }; - static Handle TargetId(const Arguments& args); - static Handle TargetType(const Arguments& args); - static Handle Name(const Arguments& args); - static Handle Tagger(const Arguments& args); - static Handle Message(const Arguments& args); - static Handle Peel(const Arguments& args); + class GetTargetWorker : public NanAsyncWorker { + public: + GetTargetWorker( + GetTargetBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetTargetWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetTargetBaton *baton; + }; + static NAN_METHOD(GetTarget); + static NAN_METHOD(TargetId); + static NAN_METHOD(TargetType); + static NAN_METHOD(Name); + static NAN_METHOD(Tagger); + static NAN_METHOD(Message); + static NAN_METHOD(Peel); git_tag *raw; }; diff --git a/include/threads.h b/include/threads.h index 7a67b0295..e66c9d06c 100755 --- a/include/threads.h +++ b/include/threads.h @@ -5,8 +5,7 @@ #ifndef GITTHREADS_H #define GITTHREADS_H -#include -#include +#include #include #include "git2.h" @@ -23,11 +22,10 @@ class GitThreads : public ObjectWrap { private: - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Init(const Arguments& args); - static Handle Shutdown(const Arguments& args); + static NAN_METHOD(Init); + static NAN_METHOD(Shutdown); }; #endif diff --git a/include/time.h b/include/time.h index b742a88b0..743c13ee7 100644 --- a/include/time.h +++ b/include/time.h @@ -5,8 +5,7 @@ #ifndef GITTIME_H #define GITTIME_H -#include -#include +#include #include #include "git2.h" @@ -28,11 +27,10 @@ class GitTime : public ObjectWrap { GitTime(git_time *raw); ~GitTime(); - static Handle New(const Arguments& args); - - static Handle Time(const Arguments& args); - static Handle Offset(const Arguments& args); + static NAN_METHOD(New); + static NAN_METHOD(Time); + static NAN_METHOD(Offset); git_time *raw; }; diff --git a/include/tree.h b/include/tree.h index 5462a82b1..b926406e2 100755 --- a/include/tree.h +++ b/include/tree.h @@ -5,8 +5,7 @@ #ifndef GITTREE_H #define GITTREE_H -#include -#include +#include #include #include "git2.h" @@ -28,85 +27,111 @@ class GitTree : public ObjectWrap { GitTree(git_tree *raw); ~GitTree(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Oid(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle EntryByName(const Arguments& args); - static Handle EntryByIndex(const Arguments& args); - static Handle EntryByOid(const Arguments& args); - static Handle GetEntry(const Arguments& args); - static void GetEntryWork(uv_work_t* req); - static void GetEntryAfterWork(uv_work_t* req); + static NAN_METHOD(Oid); + static NAN_METHOD(Size); + static NAN_METHOD(EntryByName); + static NAN_METHOD(EntryByIndex); + static NAN_METHOD(EntryByOid); struct GetEntryBaton { - uv_work_t request; int error_code; const git_error* error; git_tree_entry * out; - Persistent rootReference; git_tree * root; - Persistent pathReference; const char * path; - Persistent callback; }; - static Handle Builder(const Arguments& args); - static Handle DiffTree(const Arguments& args); - static void DiffTreeWork(uv_work_t* req); - static void DiffTreeAfterWork(uv_work_t* req); + class GetEntryWorker : public NanAsyncWorker { + public: + GetEntryWorker( + GetEntryBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetEntryWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetEntryBaton *baton; + }; + static NAN_METHOD(GetEntry); + static NAN_METHOD(Builder); struct DiffTreeBaton { - uv_work_t request; int error_code; const git_error* error; git_diff_list * diff; - Persistent repoReference; git_repository * repo; - Persistent old_treeReference; git_tree * old_tree; - Persistent new_treeReference; git_tree * new_tree; - Persistent optsReference; const git_diff_options * opts; - Persistent callback; }; - static Handle DiffIndex(const Arguments& args); - static void DiffIndexWork(uv_work_t* req); - static void DiffIndexAfterWork(uv_work_t* req); + class DiffTreeWorker : public NanAsyncWorker { + public: + DiffTreeWorker( + DiffTreeBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DiffTreeWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DiffTreeBaton *baton; + }; + static NAN_METHOD(DiffTree); struct DiffIndexBaton { - uv_work_t request; int error_code; const git_error* error; git_diff_list * diff; - Persistent repoReference; git_repository * repo; - Persistent old_treeReference; git_tree * old_tree; - Persistent indexReference; git_index * index; - Persistent optsReference; const git_diff_options * opts; - Persistent callback; }; - static Handle DiffWorkDir(const Arguments& args); - static void DiffWorkDirWork(uv_work_t* req); - static void DiffWorkDirAfterWork(uv_work_t* req); + class DiffIndexWorker : public NanAsyncWorker { + public: + DiffIndexWorker( + DiffIndexBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DiffIndexWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DiffIndexBaton *baton; + }; + static NAN_METHOD(DiffIndex); struct DiffWorkDirBaton { - uv_work_t request; int error_code; const git_error* error; git_diff_list * diff; - Persistent repoReference; git_repository * repo; - Persistent old_treeReference; git_tree * old_tree; - Persistent optsReference; const git_diff_options * opts; - Persistent callback; }; + class DiffWorkDirWorker : public NanAsyncWorker { + public: + DiffWorkDirWorker( + DiffWorkDirBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~DiffWorkDirWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + DiffWorkDirBaton *baton; + }; + static NAN_METHOD(DiffWorkDir); git_tree *raw; }; diff --git a/include/tree_builder.h b/include/tree_builder.h index 93d08a69f..093365171 100644 --- a/include/tree_builder.h +++ b/include/tree_builder.h @@ -5,8 +5,7 @@ #ifndef GITTREEBUILDER_H #define GITTREEBUILDER_H -#include -#include +#include #include #include "git2.h" @@ -28,30 +27,37 @@ class GitTreeBuilder : public ObjectWrap { GitTreeBuilder(git_treebuilder *raw); ~GitTreeBuilder(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Create(const Arguments& args); - static Handle Clear(const Arguments& args); - static Handle Size(const Arguments& args); - static Handle Get(const Arguments& args); - static Handle Insert(const Arguments& args); - static Handle GitTreebuilderRemove(const Arguments& args); - static Handle Write(const Arguments& args); - static void WriteWork(uv_work_t* req); - static void WriteAfterWork(uv_work_t* req); + static NAN_METHOD(Create); + static NAN_METHOD(Clear); + static NAN_METHOD(Size); + static NAN_METHOD(Get); + static NAN_METHOD(Insert); + static NAN_METHOD(GitTreebuilderRemove); struct WriteBaton { - uv_work_t request; int error_code; const git_error* error; git_oid * id; - Persistent repoReference; git_repository * repo; - Persistent bldReference; git_treebuilder * bld; - Persistent callback; }; + class WriteWorker : public NanAsyncWorker { + public: + WriteWorker( + WriteBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~WriteWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + WriteBaton *baton; + }; + static NAN_METHOD(Write); git_treebuilder *raw; }; diff --git a/include/tree_entry.h b/include/tree_entry.h index 7c78ec1e9..126409453 100755 --- a/include/tree_entry.h +++ b/include/tree_entry.h @@ -5,8 +5,7 @@ #ifndef GITTREEENTRY_H #define GITTREEENTRY_H -#include -#include +#include #include #include "git2.h" @@ -28,28 +27,35 @@ class GitTreeEntry : public ObjectWrap { GitTreeEntry(git_tree_entry *raw); ~GitTreeEntry(); - static Handle New(const Arguments& args); + static NAN_METHOD(New); - - static Handle Name(const Arguments& args); - static Handle Oid(const Arguments& args); - static Handle Type(const Arguments& args); - static Handle filemode(const Arguments& args); - static Handle GetObject(const Arguments& args); - static void GetObjectWork(uv_work_t* req); - static void GetObjectAfterWork(uv_work_t* req); + static NAN_METHOD(Name); + static NAN_METHOD(Oid); + static NAN_METHOD(Type); + static NAN_METHOD(filemode); struct GetObjectBaton { - uv_work_t request; int error_code; const git_error* error; git_object * object_out; - Persistent repoReference; git_repository * repo; - Persistent entryReference; const git_tree_entry * entry; - Persistent callback; }; + class GetObjectWorker : public NanAsyncWorker { + public: + GetObjectWorker( + GetObjectBaton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~GetObjectWorker() {}; + void Execute(); + void HandleOKCallback(); + + private: + GetObjectBaton *baton; + }; + static NAN_METHOD(GetObject); git_tree_entry *raw; }; diff --git a/index.js b/index.js index 53a54654a..df3fe4611 100755 --- a/index.js +++ b/index.js @@ -1,19 +1,11 @@ -// Used to detect for Cygwin -var os = require('os'); - -// Required for Windows/Cygwin support -var root = [__dirname, '/vendor/libgit2/build/shared'].join(''), - path = process.env.PATH; - -if (~os.type().indexOf('CYGWIN') && !~path.indexOf(root)) { - process.env.PATH = root + ':' + path; -} - -// Assign raw api to module var rawApi; + +// Attempt to load the production release first, if it fails fall back to the +// debug release. try { rawApi = require('./build/Release/nodegit'); -} catch (e) { +} +catch (e) { rawApi = require('./build/Debug/nodegit'); } diff --git a/install.js b/install.js index 8f86df1e0..4818e8242 100644 --- a/install.js +++ b/install.js @@ -47,6 +47,7 @@ var paths = envOverride({ pkg: __dirname + '/package', libgit2: __dirname + '/vendor/libgit2/', build: __dirname + '/vendor/libgit2/build/', + release: __dirname + '/build/Release' }); // Load the package.json. @@ -58,7 +59,7 @@ var dependencies = Q.allSettled([ // work with Python 2.* if it's available. Q.nfcall(which, 'python2'), Q.nfcall(which, 'python'), - + // Check for any version of CMake. Q.nfcall(which, 'cmake'), ]) @@ -70,17 +71,7 @@ var dependencies = Q.allSettled([ // Assign to reusable variables. python = results[0].value || results[1].value; cmake = results[2].value; - - // Missing Python. - if (!python) { - throw new Error('Python is required to build libgit2.'); - } - // Missing CMake. - if (!cmake) { - throw new Error('CMake is required to build libgit2.'); - } - // Now lets check the Python version to ensure it's < 3. return Q.nfcall(exec, python + ' --version').then(function(version) { if (version[1].indexOf('Python 3') === 0) { @@ -114,49 +105,6 @@ var dependencies = Q.allSettled([ return Q.ninvoke(expand, 'on', 'end'); }) -// Fetch completed successfully. -.then(function() { - console.info('[nodegit] Creating vendor/libgit2/build.'); - - return Q.ninvoke(fs, 'mkdir', paths.build); -}) - -// Configure libgit2 using cmake. -.then(function() { - console.info('[nodegit] Configuring libgit2.'); - - // Minimum flags necessary to configure in sane environments. - var flags = ['-DTHREADSAFE=ON', '-DBUILD_CLAR=OFF']; - - // Windows flags. - if (process.platform === 'win32') { - flags.push.apply(flags, [ - '-DSTDCALL=OFF', - '-DBUILD_SHARED_LIBS=OFF', - '-DCMAKE_C_FLAGS=-fPIC', - '-DCMAKE_BUILD_TYPE=RelWithDebInfo' - ]); - - // If the architecture is 64bit, have to change the generator. - if (os.arch() === 'x64') { - flags.push('-G "Visual Studio 12 Win64"'); - } - } - - return Q.nfcall(exec, 'cmake .. ' + flags.join(' '), { - cwd: paths.build - }); -}) - -// Build libgit2 using cmake. -.then(function() { - console.info('[nodegit] Building libgit2.'); - - return Q.nfcall(exec, 'cmake --build .', { - cwd: paths.build - }); -}) - // Configure the native module using node-gyp. .then(function() { console.info('[nodegit] Configuring native node module.'); @@ -180,6 +128,30 @@ var dependencies = Q.allSettled([ }); }) +// Attempt to fallback on a prebuilt binary. +.fail(function(message) { + console.info('[nodegit] Failed to build nodegit.'); + console.info('[nodegit] Attempting to fallback on a prebuilt binary.'); + + function fetchPrebuilt() { + console.info('[nodegit] Fetching binary from S3.'); + + // Using the node-pre-gyp module, attempt to fetch a compatible build. + return Q.nfcall(exec, 'node-pre-gyp install'); + } + + // Attempt to fetch prebuilt binary. + return Q.ninvoke(fs, 'mkdir', paths.release) + .then(fetchPrebuilt, fetchPrebuilt); +}) + +// Display a warning message about failing to build native node module. +.fail(function(message) { + console.info('[nodegit] Failed to build and install nodegit.'); + console.info(message.message); + console.info(message.stack); +}) + // Display a success message. .then(function() { console.info('[nodegit] Completed installation successfully.'); diff --git a/package.json b/package.json index f86aa0e0b..3853877f5 100644 --- a/package.json +++ b/package.json @@ -1,8 +1,8 @@ { "name": "nodegit", "description": "Node.js libgit2 asynchronous native bindings", - "version": "0.1.3", - "libgit2": "e953c1606d0d7aea680c9b19db0b955b34ae63c2", + "version": "0.1.4", + "libgit2": "a50086d174658914d4d6462afbc83b02825b1f5b", "homepage": "https://github.com/tbranyen/nodegit", "keywords": [ "libgit2", @@ -30,26 +30,37 @@ "engines": { "node": ">= 0.8" }, + "bundledDependencies": [ + "node-pre-gyp" + ], "dependencies": { - "request": "~2.25.0", - "node-gyp": "~0.13.0", - "tar": "~0.1.18", - "which": "~1.0.5", - "q": "~0.9.6", - "fs-extra": "0.6.0", - "nan": "0.8.0", - "rimraf": "~2.2.6" + "fs-extra": "~0.9.1", + "nan": "~1.2.0", + "node-gyp": "~0.13.1", + "node-pre-gyp": "~0.5.16", + "q": "~1.0.1", + "request": "~2.36.0", + "rimraf": "~2.2.8", + "tar": "~0.1.19", + "which": "~1.0.5" }, "devDependencies": { - "jshint": "~2.4.4", - "nodeunit": "~0.8.6", + "async": "~0.9.0", + "aws-sdk": "~2.0.0-rc.20", "ejs": "~1.0.0", - "async": "~0.2.10" + "jshint": "~2.5.1", + "nodeunit": "~0.9.0" + }, + "binary": { + "module_name": "nodegit", + "module_path": "./build/Release/", + "host": "https://s3.amazonaws.com/nodegit/nodegit/" }, "scripts": { "lint": "jshint src", "install": "node install.js", "test": "cd test && nodeunit nodegit.js", - "codegen": "node build/codegen/generate.js" + "codegen": "node build/codegen/generate.js", + "publish": "node-pre-gyp package && node-pre-gyp publish" } -} +} \ No newline at end of file diff --git a/src/blob.cc b/src/blob.cc index bc6068608..3ffbbb9ce 100755 --- a/src/blob.cc +++ b/src/blob.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -27,12 +26,12 @@ GitBlob::~GitBlob() { } void GitBlob::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Blob")); + tpl->SetClassName(NanNew("Blob")); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); NODE_SET_PROTOTYPE_METHOD(tpl, "content", Content); @@ -40,27 +39,27 @@ void GitBlob::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "isBinary", IsBinary); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Blob"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Blob"), _constructor_template); } -Handle GitBlob::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitBlob::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_blob is required."))); + return NanThrowError("git_blob is required."); } - - GitBlob* object = new GitBlob((git_blob *) External::Unwrap(args[0])); + GitBlob* object = new GitBlob(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitBlob::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitBlob::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitBlob::constructor_template)->NewInstance(1, argv)); } git_blob *GitBlob::GetValue() { @@ -71,8 +70,8 @@ git_blob *GitBlob::GetValue() { /** * @return {Oid} result */ -Handle GitBlob::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitBlob::Oid) { + NanScope(); const git_oid * result = git_blob_id( @@ -86,16 +85,16 @@ Handle GitBlob::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Wrapper} result */ -Handle GitBlob::Content(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitBlob::Content) { + NanScope(); const void * result = git_blob_rawcontent( @@ -106,16 +105,16 @@ Handle GitBlob::Content(const Arguments& args) { if (result != NULL) { to = Wrapper::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitBlob::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitBlob::Size) { + NanScope(); git_off_t result = git_blob_rawsize( @@ -123,15 +122,15 @@ Handle GitBlob::Size(const Arguments& args) { ); Handle to; - to = Number::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Boolean} result */ -Handle GitBlob::IsBinary(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitBlob::IsBinary) { + NanScope(); int result = git_blob_is_binary( @@ -139,8 +138,8 @@ Handle GitBlob::IsBinary(const Arguments& args) { ); Handle to; - to = Boolean::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } Persistent GitBlob::constructor_template; diff --git a/src/branch.cc b/src/branch.cc index 043afe60a..5e9a3b340 100644 --- a/src/branch.cc +++ b/src/branch.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,12 +22,12 @@ Branch::~Branch() { } void Branch::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Branch")); + tpl->SetClassName(NanNew("Branch")); NODE_SET_METHOD(tpl, "create", Create); NODE_SET_METHOD(tpl, "delete", Delete); @@ -43,27 +42,27 @@ void Branch::Initialize(Handle target) { NODE_SET_METHOD(tpl, "remoteName", RemoteName); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Branch"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Branch"), _constructor_template); } -Handle Branch::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_branch is required."))); + return NanThrowError("git_branch is required."); } - - Branch* object = new Branch((git_branch *) External::Unwrap(args[0])); + Branch* object = new Branch(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle Branch::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(Branch::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(Branch::constructor_template)->NewInstance(1, argv)); } git_branch *Branch::GetValue() { @@ -78,19 +77,19 @@ git_branch *Branch::GetValue() { * @param {Number} force * @return {Reference} out */ -Handle Branch::Create(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Create) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String branch_name is required."))); + return NanThrowError("String branch_name is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("Commit target is required."))); + return NanThrowError("Commit target is required."); } if (args.Length() == 3 || !args[3]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } git_reference * out = 0; @@ -114,9 +113,9 @@ Handle Branch::Create(const Arguments& args) { free((void *)from_branch_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -124,18 +123,18 @@ Handle Branch::Create(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Reference} branch */ -Handle Branch::Delete(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Delete) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Reference branch is required."))); + return NanThrowError("Reference branch is required."); } git_reference * from_branch; @@ -146,13 +145,13 @@ Handle Branch::Delete(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** @@ -161,19 +160,19 @@ Handle Branch::Delete(const Arguments& args) { * @param {BranchForeachCb} branch_cb * @param {void} payload */ -Handle Branch::Foreach(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Foreach) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number list_flags is required."))); + return NanThrowError("Number list_flags is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("BranchForeachCb branch_cb is required."))); + return NanThrowError("BranchForeachCb branch_cb is required."); } if (args.Length() == 3 || !args[3]->IsObject()) { - return ThrowException(Exception::Error(String::New("void payload is required."))); + return NanThrowError("void payload is required."); } git_repository * from_repo; @@ -193,13 +192,13 @@ Handle Branch::Foreach(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** @@ -208,16 +207,16 @@ Handle Branch::Foreach(const Arguments& args) { * @param {Number} force * @return {Reference} out */ -Handle Branch::Move(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Move) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Reference branch is required."))); + return NanThrowError("Reference branch is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String new_branch_name is required."))); + return NanThrowError("String new_branch_name is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } git_reference * out = 0; @@ -238,9 +237,9 @@ Handle Branch::Move(const Arguments& args) { free((void *)from_new_branch_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -248,9 +247,9 @@ Handle Branch::Move(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -259,16 +258,16 @@ Handle Branch::Move(const Arguments& args) { * @param {BranchT} branch_type * @return {Reference} out */ -Handle Branch::Lookup(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Lookup) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String branch_name is required."))); + return NanThrowError("String branch_name is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("BranchT branch_type is required."))); + return NanThrowError("BranchT branch_type is required."); } git_reference * out = 0; @@ -289,9 +288,9 @@ Handle Branch::Lookup(const Arguments& args) { free((void *)from_branch_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -299,19 +298,19 @@ Handle Branch::Lookup(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Reference} ref * @return {String} out */ -Handle Branch::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Name) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Reference ref is required."))); + return NanThrowError("Reference ref is required."); } const char * out = 0; @@ -324,25 +323,25 @@ Handle Branch::Name(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } Handle to; - to = String::New(out); - return scope.Close(to); + to = NanNew(out); + NanReturnValue(to); } /** * @param {Reference} branch * @return {Reference} out */ -Handle Branch::Upstream(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::Upstream) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Reference branch is required."))); + return NanThrowError("Reference branch is required."); } git_reference * out = 0; @@ -355,9 +354,9 @@ Handle Branch::Upstream(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -365,22 +364,22 @@ Handle Branch::Upstream(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Reference} branch * @param {String} upstream_name */ -Handle Branch::SetUpstream(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::SetUpstream) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Reference branch is required."))); + return NanThrowError("Reference branch is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String upstream_name is required."))); + return NanThrowError("String upstream_name is required."); } git_reference * from_branch; @@ -396,13 +395,13 @@ Handle Branch::SetUpstream(const Arguments& args) { free((void *)from_upstream_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** @@ -411,19 +410,19 @@ Handle Branch::SetUpstream(const Arguments& args) { * @param {Repository} repo * @param {String} canonical_branch_name */ -Handle Branch::UpstreamName(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::UpstreamName) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String tracking_branch_name_out is required."))); + return NanThrowError("String tracking_branch_name_out is required."); } if (args.Length() == 1 || !args[1]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number buffer_size is required."))); + return NanThrowError("Number buffer_size is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 3 || !args[3]->IsString()) { - return ThrowException(Exception::Error(String::New("String canonical_branch_name is required."))); + return NanThrowError("String canonical_branch_name is required."); } char * from_tracking_branch_name_out; @@ -447,22 +446,22 @@ Handle Branch::UpstreamName(const Arguments& args) { free((void *)from_canonical_branch_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {Reference} branch */ -Handle Branch::IsHead(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::IsHead) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Reference branch is required."))); + return NanThrowError("Reference branch is required."); } git_reference * from_branch; @@ -473,13 +472,13 @@ Handle Branch::IsHead(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** @@ -488,19 +487,19 @@ Handle Branch::IsHead(const Arguments& args) { * @param {Repository} repo * @param {String} canonical_branch_name */ -Handle Branch::RemoteName(const Arguments& args) { - HandleScope scope; +NAN_METHOD(Branch::RemoteName) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String remote_name_out is required."))); + return NanThrowError("String remote_name_out is required."); } if (args.Length() == 1 || !args[1]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number buffer_size is required."))); + return NanThrowError("Number buffer_size is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 3 || !args[3]->IsString()) { - return ThrowException(Exception::Error(String::New("String canonical_branch_name is required."))); + return NanThrowError("String canonical_branch_name is required."); } char * from_remote_name_out; @@ -524,13 +523,13 @@ Handle Branch::RemoteName(const Arguments& args) { free((void *)from_canonical_branch_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } Persistent Branch::constructor_template; diff --git a/src/clone_options.cc b/src/clone_options.cc index 3f4b058c5..c6812d369 100644 --- a/src/clone_options.cc +++ b/src/clone_options.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,36 +22,36 @@ GitCloneOptions::~GitCloneOptions() { } void GitCloneOptions::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("CloneOptions")); + tpl->SetClassName(NanNew("CloneOptions")); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("CloneOptions"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("CloneOptions"), _constructor_template); } -Handle GitCloneOptions::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCloneOptions::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_clone_options is required."))); + return NanThrowError("git_clone_options is required."); } - - GitCloneOptions* object = new GitCloneOptions((git_clone_options *) External::Unwrap(args[0])); + GitCloneOptions* object = new GitCloneOptions(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitCloneOptions::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitCloneOptions::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitCloneOptions::constructor_template)->NewInstance(1, argv)); } git_clone_options *GitCloneOptions::GetValue() { diff --git a/src/commit.cc b/src/commit.cc index 29a1a7877..0ccd639b3 100755 --- a/src/commit.cc +++ b/src/commit.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -27,12 +26,12 @@ GitCommit::~GitCommit() { } void GitCommit::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Commit")); + tpl->SetClassName(NanNew("Commit")); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); NODE_SET_PROTOTYPE_METHOD(tpl, "messageEncoding", MessageEncoding); @@ -47,27 +46,27 @@ void GitCommit::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "nthGenAncestor", NthGenAncestor); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Commit"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Commit"), _constructor_template); } -Handle GitCommit::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_commit is required."))); + return NanThrowError("git_commit is required."); } - - GitCommit* object = new GitCommit((git_commit *) External::Unwrap(args[0])); + GitCommit* object = new GitCommit(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitCommit::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitCommit::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitCommit::constructor_template)->NewInstance(1, argv)); } git_commit *GitCommit::GetValue() { @@ -78,8 +77,8 @@ git_commit *GitCommit::GetValue() { /** * @return {Oid} result */ -Handle GitCommit::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::Oid) { + NanScope(); const git_oid * result = git_commit_id( @@ -93,16 +92,16 @@ Handle GitCommit::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitCommit::MessageEncoding(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::MessageEncoding) { + NanScope(); const char * result = git_commit_message_encoding( @@ -110,15 +109,15 @@ Handle GitCommit::MessageEncoding(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitCommit::Message(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::Message) { + NanScope(); const char * result = git_commit_message( @@ -126,15 +125,15 @@ Handle GitCommit::Message(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitCommit::Time(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::Time) { + NanScope(); git_time_t result = git_commit_time( @@ -142,15 +141,15 @@ Handle GitCommit::Time(const Arguments& args) { ); Handle to; - to = Number::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitCommit::Offset(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::Offset) { + NanScope(); int result = git_commit_time_offset( @@ -158,15 +157,15 @@ Handle GitCommit::Offset(const Arguments& args) { ); Handle to; - to = Integer::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Signature} result */ -Handle GitCommit::Committer(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::Committer) { + NanScope(); const git_signature * result = git_commit_committer( @@ -180,16 +179,16 @@ Handle GitCommit::Committer(const Arguments& args) { if (result != NULL) { to = GitSignature::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Signature} result */ -Handle GitCommit::Author(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::Author) { + NanScope(); const git_signature * result = git_commit_author( @@ -203,16 +202,16 @@ Handle GitCommit::Author(const Arguments& args) { if (result != NULL) { to = GitSignature::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Oid} result */ -Handle GitCommit::TreeId(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::TreeId) { + NanScope(); const git_oid * result = git_commit_tree_id( @@ -226,16 +225,16 @@ Handle GitCommit::TreeId(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitCommit::ParentCount(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::ParentCount) { + NanScope(); unsigned int result = git_commit_parentcount( @@ -243,18 +242,18 @@ Handle GitCommit::ParentCount(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** * @param {Number} n * @return {Oid} result */ -Handle GitCommit::ParentId(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::ParentId) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number n is required."))); + return NanThrowError("Number n is required."); } unsigned int from_n; @@ -272,19 +271,19 @@ Handle GitCommit::ParentId(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Number} n * @return {Commit} ancestor */ -Handle GitCommit::NthGenAncestor(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitCommit::NthGenAncestor) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number n is required."))); + return NanThrowError("Number n is required."); } git_commit * ancestor = 0; @@ -298,9 +297,9 @@ Handle GitCommit::NthGenAncestor(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -308,9 +307,9 @@ Handle GitCommit::NthGenAncestor(const Arguments& args) { if (ancestor != NULL) { to = GitCommit::New((void *)ancestor); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } Persistent GitCommit::constructor_template; diff --git a/src/delta.cc b/src/delta.cc index 7b45d35f9..1428032c2 100644 --- a/src/delta.cc +++ b/src/delta.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -24,12 +23,12 @@ GitDelta::~GitDelta() { } void GitDelta::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Delta")); + tpl->SetClassName(NanNew("Delta")); NODE_SET_PROTOTYPE_METHOD(tpl, "oldFile", OldFile); @@ -38,27 +37,27 @@ void GitDelta::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "similarity", Similarity); NODE_SET_PROTOTYPE_METHOD(tpl, "flags", Flags); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Delta"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Delta"), _constructor_template); } -Handle GitDelta::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDelta::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_delta is required."))); + return NanThrowError("git_diff_delta is required."); } - - GitDelta* object = new GitDelta((git_diff_delta *) External::Unwrap(args[0])); + GitDelta* object = new GitDelta(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitDelta::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitDelta::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitDelta::constructor_template)->NewInstance(1, argv)); } git_diff_delta *GitDelta::GetValue() { @@ -66,8 +65,8 @@ git_diff_delta *GitDelta::GetValue() { } -Handle GitDelta::OldFile(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDelta::OldFile) { + NanScope(); Handle to; git_diff_file *old_file = @@ -79,13 +78,13 @@ Handle GitDelta::OldFile(const Arguments& args) { if (old_file != NULL) { to = GitDiffFile::New((void *)old_file); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitDelta::NewFile(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDelta::NewFile) { + NanScope(); Handle to; git_diff_file *new_file = @@ -97,42 +96,42 @@ Handle GitDelta::NewFile(const Arguments& args) { if (new_file != NULL) { to = GitDiffFile::New((void *)new_file); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitDelta::Status(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDelta::Status) { + NanScope(); Handle to; git_delta_t status = ObjectWrap::Unwrap(args.This())->GetValue()->status; - to = Integer::New(status); - return scope.Close(to); + to = NanNew(status); + NanReturnValue(to); } -Handle GitDelta::Similarity(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDelta::Similarity) { + NanScope(); Handle to; uint32_t similarity = ObjectWrap::Unwrap(args.This())->GetValue()->similarity; - to = Integer::New(similarity); - return scope.Close(to); + to = NanNew(similarity); + NanReturnValue(to); } -Handle GitDelta::Flags(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDelta::Flags) { + NanScope(); Handle to; uint32_t flags = ObjectWrap::Unwrap(args.This())->GetValue()->flags; - to = Integer::New(flags); - return scope.Close(to); + to = NanNew(flags); + NanReturnValue(to); } Persistent GitDelta::constructor_template; diff --git a/src/diff_file.cc b/src/diff_file.cc index c96d4c8be..b19711520 100644 --- a/src/diff_file.cc +++ b/src/diff_file.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -24,12 +23,12 @@ GitDiffFile::~GitDiffFile() { } void GitDiffFile::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("DiffFile")); + tpl->SetClassName(NanNew("DiffFile")); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); @@ -38,27 +37,27 @@ void GitDiffFile::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "flags", Flags); NODE_SET_PROTOTYPE_METHOD(tpl, "mode", Mode); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("DiffFile"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("DiffFile"), _constructor_template); } -Handle GitDiffFile::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFile::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_file is required."))); + return NanThrowError("git_diff_file is required."); } - - GitDiffFile* object = new GitDiffFile((git_diff_file *) External::Unwrap(args[0])); + GitDiffFile* object = new GitDiffFile(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitDiffFile::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitDiffFile::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitDiffFile::constructor_template)->NewInstance(1, argv)); } git_diff_file *GitDiffFile::GetValue() { @@ -66,8 +65,8 @@ git_diff_file *GitDiffFile::GetValue() { } -Handle GitDiffFile::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFile::Oid) { + NanScope(); Handle to; git_oid *oid = @@ -79,53 +78,53 @@ Handle GitDiffFile::Oid(const Arguments& args) { if (oid != NULL) { to = GitOid::New((void *)oid); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitDiffFile::Path(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFile::Path) { + NanScope(); Handle to; const char * path = ObjectWrap::Unwrap(args.This())->GetValue()->path; - to = String::New(path); - return scope.Close(to); + to = NanNew(path); + NanReturnValue(to); } -Handle GitDiffFile::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFile::Size) { + NanScope(); Handle to; git_off_t size = ObjectWrap::Unwrap(args.This())->GetValue()->size; - to = Integer::New(size); - return scope.Close(to); + to = NanNew(size); + NanReturnValue(to); } -Handle GitDiffFile::Flags(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFile::Flags) { + NanScope(); Handle to; uint32_t flags = ObjectWrap::Unwrap(args.This())->GetValue()->flags; - to = Integer::New(flags); - return scope.Close(to); + to = NanNew(flags); + NanReturnValue(to); } -Handle GitDiffFile::Mode(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFile::Mode) { + NanScope(); Handle to; uint16_t mode = ObjectWrap::Unwrap(args.This())->GetValue()->mode; - to = Integer::New(mode); - return scope.Close(to); + to = NanNew(mode); + NanReturnValue(to); } Persistent GitDiffFile::constructor_template; diff --git a/src/diff_find_options.cc b/src/diff_find_options.cc index f6fd85756..20421c3f1 100644 --- a/src/diff_find_options.cc +++ b/src/diff_find_options.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,36 +22,36 @@ GitDiffFindOptions::~GitDiffFindOptions() { } void GitDiffFindOptions::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("DiffFindOptions")); + tpl->SetClassName(NanNew("DiffFindOptions")); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("DiffFindOptions"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("DiffFindOptions"), _constructor_template); } -Handle GitDiffFindOptions::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffFindOptions::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_find_options is required."))); + return NanThrowError("git_diff_find_options is required."); } - - GitDiffFindOptions* object = new GitDiffFindOptions((git_diff_find_options *) External::Unwrap(args[0])); + GitDiffFindOptions* object = new GitDiffFindOptions(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitDiffFindOptions::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitDiffFindOptions::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitDiffFindOptions::constructor_template)->NewInstance(1, argv)); } git_diff_find_options *GitDiffFindOptions::GetValue() { diff --git a/src/diff_list.cc b/src/diff_list.cc index fbd7e1398..3a0985400 100755 --- a/src/diff_list.cc +++ b/src/diff_list.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -30,12 +29,12 @@ GitDiffList::~GitDiffList() { } void GitDiffList::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("DiffList")); + tpl->SetClassName(NanNew("DiffList")); NODE_SET_PROTOTYPE_METHOD(tpl, "merge", Merge); NODE_SET_PROTOTYPE_METHOD(tpl, "findSimilar", FindSimilar); @@ -44,27 +43,27 @@ void GitDiffList::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "patch", Patch); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("DiffList"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("DiffList"), _constructor_template); } -Handle GitDiffList::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffList::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_list is required."))); + return NanThrowError("git_diff_list is required."); } - - GitDiffList* object = new GitDiffList((git_diff_list *) External::Unwrap(args[0])); + GitDiffList* object = new GitDiffList(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitDiffList::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitDiffList::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitDiffList::constructor_template)->NewInstance(1, argv)); } git_diff_list *GitDiffList::GetValue() { @@ -75,10 +74,10 @@ git_diff_list *GitDiffList::GetValue() { /** * @param {DiffList} from */ -Handle GitDiffList::Merge(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffList::Merge) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("DiffList from is required."))); + return NanThrowError("DiffList from is required."); } const git_diff_list * from_from; @@ -90,22 +89,22 @@ Handle GitDiffList::Merge(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {DiffFindOptions} options */ -Handle GitDiffList::FindSimilar(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffList::FindSimilar) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("DiffFindOptions options is required."))); + return NanThrowError("DiffFindOptions options is required."); } git_diff_find_options * from_options; @@ -117,20 +116,20 @@ Handle GitDiffList::FindSimilar(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @return {Number} result */ -Handle GitDiffList::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffList::Size) { + NanScope(); size_t result = git_diff_num_deltas( @@ -138,8 +137,8 @@ Handle GitDiffList::Size(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** @@ -147,13 +146,13 @@ Handle GitDiffList::Size(const Arguments& args) { * @param {Number} type * @return {Number} result */ -Handle GitDiffList::NumDeltasOfType(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffList::NumDeltasOfType) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("DiffList diff is required."))); + return NanThrowError("DiffList diff is required."); } if (args.Length() == 1 || !args[1]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number type is required."))); + return NanThrowError("Number type is required."); } git_diff_list * from_diff; @@ -167,8 +166,8 @@ Handle GitDiffList::NumDeltasOfType(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** @@ -176,10 +175,10 @@ Handle GitDiffList::NumDeltasOfType(const Arguments& args) { * @return {Patch} patch_out * @return {Delta} delta_out */ -Handle GitDiffList::Patch(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffList::Patch) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number idx is required."))); + return NanThrowError("Number idx is required."); } git_diff_patch * patch_out = 0; @@ -195,20 +194,20 @@ Handle GitDiffList::Patch(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - Handle toReturn = Object::New(); + Handle toReturn = NanNew(); Handle to; if (patch_out != NULL) { to = GitPatch::New((void *)patch_out); } else { - to = Null(); + to = NanNull(); } - toReturn->Set(String::NewSymbol("patch"), to); + toReturn->Set(NanNew("patch"), to); if (delta_out != NULL) { delta_out = (const git_diff_delta * )git_diff_delta_dup(delta_out); @@ -216,11 +215,11 @@ Handle GitDiffList::Patch(const Arguments& args) { if (delta_out != NULL) { to = GitDelta::New((void *)delta_out); } else { - to = Null(); + to = NanNull(); } - toReturn->Set(String::NewSymbol("delta"), to); + toReturn->Set(NanNew("delta"), to); - return scope.Close(toReturn); + NanReturnValue(toReturn); } Persistent GitDiffList::constructor_template; diff --git a/src/diff_options.cc b/src/diff_options.cc index dad3fd108..75a3bc129 100644 --- a/src/diff_options.cc +++ b/src/diff_options.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,36 +22,36 @@ GitDiffOptions::~GitDiffOptions() { } void GitDiffOptions::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("DiffOptions")); + tpl->SetClassName(NanNew("DiffOptions")); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("DiffOptions"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("DiffOptions"), _constructor_template); } -Handle GitDiffOptions::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffOptions::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_options is required."))); + return NanThrowError("git_diff_options is required."); } - - GitDiffOptions* object = new GitDiffOptions((git_diff_options *) External::Unwrap(args[0])); + GitDiffOptions* object = new GitDiffOptions(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitDiffOptions::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitDiffOptions::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitDiffOptions::constructor_template)->NewInstance(1, argv)); } git_diff_options *GitDiffOptions::GetValue() { diff --git a/src/diff_range.cc b/src/diff_range.cc index cacbd49b5..82c2b5fc4 100644 --- a/src/diff_range.cc +++ b/src/diff_range.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,12 +22,12 @@ GitDiffRange::~GitDiffRange() { } void GitDiffRange::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("DiffRange")); + tpl->SetClassName(NanNew("DiffRange")); NODE_SET_PROTOTYPE_METHOD(tpl, "oldStart", OldStart); @@ -36,27 +35,27 @@ void GitDiffRange::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "newStart", NewStart); NODE_SET_PROTOTYPE_METHOD(tpl, "newLines", NewLines); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("DiffRange"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("DiffRange"), _constructor_template); } -Handle GitDiffRange::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffRange::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_range is required."))); + return NanThrowError("git_diff_range is required."); } - - GitDiffRange* object = new GitDiffRange((git_diff_range *) External::Unwrap(args[0])); + GitDiffRange* object = new GitDiffRange(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitDiffRange::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitDiffRange::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitDiffRange::constructor_template)->NewInstance(1, argv)); } git_diff_range *GitDiffRange::GetValue() { @@ -64,48 +63,48 @@ git_diff_range *GitDiffRange::GetValue() { } -Handle GitDiffRange::OldStart(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffRange::OldStart) { + NanScope(); Handle to; int old_start = ObjectWrap::Unwrap(args.This())->GetValue()->old_start; - to = Integer::New(old_start); - return scope.Close(to); + to = NanNew(old_start); + NanReturnValue(to); } -Handle GitDiffRange::OldLines(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffRange::OldLines) { + NanScope(); Handle to; int old_lines = ObjectWrap::Unwrap(args.This())->GetValue()->old_lines; - to = Integer::New(old_lines); - return scope.Close(to); + to = NanNew(old_lines); + NanReturnValue(to); } -Handle GitDiffRange::NewStart(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffRange::NewStart) { + NanScope(); Handle to; int new_start = ObjectWrap::Unwrap(args.This())->GetValue()->new_start; - to = Integer::New(new_start); - return scope.Close(to); + to = NanNew(new_start); + NanReturnValue(to); } -Handle GitDiffRange::NewLines(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitDiffRange::NewLines) { + NanScope(); Handle to; int new_lines = ObjectWrap::Unwrap(args.This())->GetValue()->new_lines; - to = Integer::New(new_lines); - return scope.Close(to); + to = NanNew(new_lines); + NanReturnValue(to); } Persistent GitDiffRange::constructor_template; diff --git a/src/index.cc b/src/index.cc index adeaf91be..fc0e7a0c3 100644 --- a/src/index.cc +++ b/src/index.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -29,12 +28,12 @@ GitIndex::~GitIndex() { } void GitIndex::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Index")); + tpl->SetClassName(NanNew("Index")); NODE_SET_METHOD(tpl, "open", Open); NODE_SET_PROTOTYPE_METHOD(tpl, "read", Read); @@ -55,27 +54,27 @@ void GitIndex::Initialize(Handle target) { NODE_SET_METHOD(tpl, "indexToWorkdir", IndexToWorkdir); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Index"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Index"), _constructor_template); } -Handle GitIndex::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_index is required."))); + return NanThrowError("git_index is required."); } - - GitIndex* object = new GitIndex((git_index *) External::Unwrap(args[0])); + GitIndex* object = new GitIndex(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitIndex::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitIndex::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitIndex::constructor_template)->NewInstance(1, argv)); } git_index *GitIndex::GetValue() { @@ -89,34 +88,34 @@ git_index *GitIndex::GetValue() { * @param {String} index_path * @param {Index} callback */ -Handle GitIndex::Open(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Open) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String index_path is required."))); + return NanThrowError("String index_path is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } OpenBaton* baton = new OpenBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->index_pathReference = Persistent::New(args[0]); const char * from_index_path; String::Utf8Value index_path(args[0]->ToString()); from_index_path = strdup(*index_path); baton->index_path = from_index_path; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, OpenWork, (uv_after_work_cb)OpenAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + OpenWorker *worker = new OpenWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("index_path", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::OpenWork(uv_work_t *req) { - OpenBaton *baton = static_cast(req->data); +void GitIndex::OpenWorker::Execute() { int result = git_index_open( &baton->out, baton->index_path @@ -127,43 +126,38 @@ void GitIndex::OpenWork(uv_work_t *req) { } } -void GitIndex::OpenAfterWork(uv_work_t *req) { - HandleScope scope; - OpenBaton *baton = static_cast(req->data); - +void GitIndex::OpenWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitIndex::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->index_pathReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->index_path); delete baton; } @@ -172,28 +166,27 @@ void GitIndex::OpenAfterWork(uv_work_t *req) { /** */ -Handle GitIndex::Read(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Read) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ReadBaton* baton = new ReadBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->indexReference = Persistent::New(args.This()); baton->index = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, ReadWork, (uv_after_work_cb)ReadAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + ReadWorker *worker = new ReadWorker(baton, callback); + worker->SaveToPersistent("index", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::ReadWork(uv_work_t *req) { - ReadBaton *baton = static_cast(req->data); +void GitIndex::ReadWorker::Execute() { int result = git_index_read( baton->index ); @@ -203,37 +196,32 @@ void GitIndex::ReadWork(uv_work_t *req) { } } -void GitIndex::ReadAfterWork(uv_work_t *req) { - HandleScope scope; - ReadBaton *baton = static_cast(req->data); - +void GitIndex::ReadWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->indexReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -241,28 +229,27 @@ void GitIndex::ReadAfterWork(uv_work_t *req) { /** */ -Handle GitIndex::Write(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Write) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } WriteBaton* baton = new WriteBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->indexReference = Persistent::New(args.This()); baton->index = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, WriteWork, (uv_after_work_cb)WriteAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + WriteWorker *worker = new WriteWorker(baton, callback); + worker->SaveToPersistent("index", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::WriteWork(uv_work_t *req) { - WriteBaton *baton = static_cast(req->data); +void GitIndex::WriteWorker::Execute() { int result = git_index_write( baton->index ); @@ -272,37 +259,32 @@ void GitIndex::WriteWork(uv_work_t *req) { } } -void GitIndex::WriteAfterWork(uv_work_t *req) { - HandleScope scope; - WriteBaton *baton = static_cast(req->data); - +void GitIndex::WriteWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->indexReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -311,35 +293,35 @@ void GitIndex::WriteAfterWork(uv_work_t *req) { /** * @param {Tree} tree */ -Handle GitIndex::ReadTree(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::ReadTree) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Tree tree is required."))); + return NanThrowError("Tree tree is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ReadTreeBaton* baton = new ReadTreeBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->indexReference = Persistent::New(args.This()); baton->index = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->treeReference = Persistent::New(args[0]); const git_tree * from_tree; from_tree = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->tree = from_tree; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, ReadTreeWork, (uv_after_work_cb)ReadTreeAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + ReadTreeWorker *worker = new ReadTreeWorker(baton, callback); + worker->SaveToPersistent("index", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("tree", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::ReadTreeWork(uv_work_t *req) { - ReadTreeBaton *baton = static_cast(req->data); +void GitIndex::ReadTreeWorker::Execute() { int result = git_index_read_tree( baton->index, baton->tree @@ -350,38 +332,32 @@ void GitIndex::ReadTreeWork(uv_work_t *req) { } } -void GitIndex::ReadTreeAfterWork(uv_work_t *req) { - HandleScope scope; - ReadTreeBaton *baton = static_cast(req->data); - +void GitIndex::ReadTreeWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->indexReference.Dispose(); - baton->treeReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -390,29 +366,28 @@ void GitIndex::ReadTreeAfterWork(uv_work_t *req) { /** * @param {Oid} callback */ -Handle GitIndex::WriteTree(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::WriteTree) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } WriteTreeBaton* baton = new WriteTreeBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->out = (git_oid *)malloc(sizeof(git_oid )); - baton->indexReference = Persistent::New(args.This()); baton->index = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, WriteTreeWork, (uv_after_work_cb)WriteTreeAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + WriteTreeWorker *worker = new WriteTreeWorker(baton, callback); + worker->SaveToPersistent("index", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::WriteTreeWork(uv_work_t *req) { - WriteTreeBaton *baton = static_cast(req->data); +void GitIndex::WriteTreeWorker::Execute() { int result = git_index_write_tree( baton->out, baton->index @@ -423,35 +398,32 @@ void GitIndex::WriteTreeWork(uv_work_t *req) { } } -void GitIndex::WriteTreeAfterWork(uv_work_t *req) { - HandleScope scope; - WriteTreeBaton *baton = static_cast(req->data); - +void GitIndex::WriteTreeWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitOid::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->out); } @@ -459,16 +431,14 @@ void GitIndex::WriteTreeAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->indexReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** * @return {Number} result */ -Handle GitIndex::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Size) { + NanScope(); size_t result = git_index_entrycount( @@ -476,31 +446,31 @@ Handle GitIndex::Size(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** */ -Handle GitIndex::Clear(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Clear) { + NanScope(); git_index_clear( ObjectWrap::Unwrap(args.This())->GetValue() ); - return Undefined(); + NanReturnUndefined(); } /** * @param {Number} n * @return {IndexEntry} result */ -Handle GitIndex::Entry(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Entry) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number n is required."))); + return NanThrowError("Number n is required."); } size_t from_n; @@ -518,22 +488,22 @@ Handle GitIndex::Entry(const Arguments& args) { if (result != NULL) { to = GitIndexEntry::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {String} path * @param {Number} stage */ -Handle GitIndex::Remove(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Remove) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number stage is required."))); + return NanThrowError("Number stage is required."); } const char * from_path; @@ -550,26 +520,26 @@ Handle GitIndex::Remove(const Arguments& args) { free((void *)from_path); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {String} dir * @param {Number} stage */ -Handle GitIndex::RemoveDirectory(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::RemoveDirectory) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String dir is required."))); + return NanThrowError("String dir is required."); } if (args.Length() == 1 || !args[1]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number stage is required."))); + return NanThrowError("Number stage is required."); } const char * from_dir; @@ -586,13 +556,13 @@ Handle GitIndex::RemoveDirectory(const Arguments& args) { free((void *)from_dir); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" @@ -600,36 +570,36 @@ Handle GitIndex::RemoveDirectory(const Arguments& args) { /** * @param {String} path */ -Handle GitIndex::AddBypath(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::AddBypath) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } AddBypathBaton* baton = new AddBypathBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->indexReference = Persistent::New(args.This()); baton->index = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->pathReference = Persistent::New(args[0]); const char * from_path; String::Utf8Value path(args[0]->ToString()); from_path = strdup(*path); baton->path = from_path; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, AddBypathWork, (uv_after_work_cb)AddBypathAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + AddBypathWorker *worker = new AddBypathWorker(baton, callback); + worker->SaveToPersistent("index", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("path", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::AddBypathWork(uv_work_t *req) { - AddBypathBaton *baton = static_cast(req->data); +void GitIndex::AddBypathWorker::Execute() { int result = git_index_add_bypath( baton->index, baton->path @@ -640,38 +610,32 @@ void GitIndex::AddBypathWork(uv_work_t *req) { } } -void GitIndex::AddBypathAfterWork(uv_work_t *req) { - HandleScope scope; - AddBypathBaton *baton = static_cast(req->data); - +void GitIndex::AddBypathWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->indexReference.Dispose(); - baton->pathReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->path); delete baton; } @@ -679,10 +643,10 @@ void GitIndex::AddBypathAfterWork(uv_work_t *req) { /** * @param {String} path */ -Handle GitIndex::RemoveBypath(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::RemoveBypath) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } const char * from_path; @@ -696,23 +660,23 @@ Handle GitIndex::RemoveBypath(const Arguments& args) { free((void *)from_path); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {String} path * @return {Number} at_pos */ -Handle GitIndex::Find(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::Find) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } size_t at_pos = 0; @@ -728,17 +692,17 @@ Handle GitIndex::Find(const Arguments& args) { free((void *)from_path); Handle to; - to = Uint32::New(at_pos); - return scope.Close(to); + to = NanNew((uint32_t)at_pos); + NanReturnValue(to); } /** * @param {String} path */ -Handle GitIndex::ConflictRemove(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::ConflictRemove) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } const char * from_path; @@ -752,33 +716,33 @@ Handle GitIndex::ConflictRemove(const Arguments& args) { free((void *)from_path); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** */ -Handle GitIndex::ConflictCleanup(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::ConflictCleanup) { + NanScope(); git_index_conflict_cleanup( ObjectWrap::Unwrap(args.This())->GetValue() ); - return Undefined(); + NanReturnUndefined(); } /** * @return {Number} result */ -Handle GitIndex::HasConflicts(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::HasConflicts) { + NanScope(); int result = git_index_has_conflicts( @@ -786,8 +750,8 @@ Handle GitIndex::HasConflicts(const Arguments& args) { ); Handle to; - to = Int32::New(result); - return scope.Close(to); + to = NanNew((int32_t)result); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -798,49 +762,51 @@ Handle GitIndex::HasConflicts(const Arguments& args) { * @param {DiffOptions} opts * @param {DiffList} callback */ -Handle GitIndex::IndexToWorkdir(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndex::IndexToWorkdir) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 3 || !args[3]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } IndexToWorkdirBaton* baton = new IndexToWorkdirBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->indexReference = Persistent::New(args[1]); - git_index * from_index; + git_index * from_index; if (args[1]->IsObject()) { from_index = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); } else { from_index = 0; } baton->index = from_index; - baton->optsReference = Persistent::New(args[2]); - const git_diff_options * from_opts; + const git_diff_options * from_opts; if (args[2]->IsObject()) { from_opts = ObjectWrap::Unwrap(args[2]->ToObject())->GetValue(); } else { from_opts = 0; } baton->opts = from_opts; - baton->callback = Persistent::New(Local::Cast(args[3])); - - uv_queue_work(uv_default_loop(), &baton->request, IndexToWorkdirWork, (uv_after_work_cb)IndexToWorkdirAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[3])); + IndexToWorkdirWorker *worker = new IndexToWorkdirWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("index", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("opts", args[2]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitIndex::IndexToWorkdirWork(uv_work_t *req) { - IndexToWorkdirBaton *baton = static_cast(req->data); +void GitIndex::IndexToWorkdirWorker::Execute() { int result = git_diff_index_to_workdir( &baton->diff, baton->repo, @@ -853,45 +819,38 @@ void GitIndex::IndexToWorkdirWork(uv_work_t *req) { } } -void GitIndex::IndexToWorkdirAfterWork(uv_work_t *req) { - HandleScope scope; - IndexToWorkdirBaton *baton = static_cast(req->data); - +void GitIndex::IndexToWorkdirWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->diff != NULL) { to = GitDiffList::New((void *)baton->diff); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->indexReference.Dispose(); - baton->optsReference.Dispose(); - baton->callback.Dispose(); delete baton; } diff --git a/src/index_entry.cc b/src/index_entry.cc index 933ffafda..0fef443c1 100644 --- a/src/index_entry.cc +++ b/src/index_entry.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -25,12 +24,12 @@ GitIndexEntry::~GitIndexEntry() { } void GitIndexEntry::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("IndexEntry")); + tpl->SetClassName(NanNew("IndexEntry")); NODE_SET_PROTOTYPE_METHOD(tpl, "ctime", Ctime); @@ -46,27 +45,27 @@ void GitIndexEntry::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "flags_extended", FlagsExtended); NODE_SET_PROTOTYPE_METHOD(tpl, "path", Path); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("IndexEntry"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("IndexEntry"), _constructor_template); } -Handle GitIndexEntry::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_index_entry is required."))); + return NanThrowError("git_index_entry is required."); } - - GitIndexEntry* object = new GitIndexEntry((git_index_entry *) External::Unwrap(args[0])); + GitIndexEntry* object = new GitIndexEntry(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitIndexEntry::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitIndexEntry::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitIndexEntry::constructor_template)->NewInstance(1, argv)); } git_index_entry *GitIndexEntry::GetValue() { @@ -74,8 +73,8 @@ git_index_entry *GitIndexEntry::GetValue() { } -Handle GitIndexEntry::Ctime(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Ctime) { + NanScope(); Handle to; git_index_time *ctime = @@ -87,13 +86,13 @@ Handle GitIndexEntry::Ctime(const Arguments& args) { if (ctime != NULL) { to = GitIndexTime::New((void *)ctime); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitIndexEntry::Mtime(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Mtime) { + NanScope(); Handle to; git_index_time *mtime = @@ -105,79 +104,79 @@ Handle GitIndexEntry::Mtime(const Arguments& args) { if (mtime != NULL) { to = GitIndexTime::New((void *)mtime); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitIndexEntry::Dev(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Dev) { + NanScope(); Handle to; unsigned int dev = ObjectWrap::Unwrap(args.This())->GetValue()->dev; - to = Uint32::New(dev); - return scope.Close(to); + to = NanNew((uint32_t)dev); + NanReturnValue(to); } -Handle GitIndexEntry::Ino(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Ino) { + NanScope(); Handle to; unsigned int ino = ObjectWrap::Unwrap(args.This())->GetValue()->ino; - to = Uint32::New(ino); - return scope.Close(to); + to = NanNew((uint32_t)ino); + NanReturnValue(to); } -Handle GitIndexEntry::Mode(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Mode) { + NanScope(); Handle to; uint16_t mode = ObjectWrap::Unwrap(args.This())->GetValue()->mode; - to = Integer::New(mode); - return scope.Close(to); + to = NanNew(mode); + NanReturnValue(to); } -Handle GitIndexEntry::Uid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Uid) { + NanScope(); Handle to; unsigned int uid = ObjectWrap::Unwrap(args.This())->GetValue()->uid; - to = Uint32::New(uid); - return scope.Close(to); + to = NanNew((uint32_t)uid); + NanReturnValue(to); } -Handle GitIndexEntry::gid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::gid) { + NanScope(); Handle to; unsigned int gid = ObjectWrap::Unwrap(args.This())->GetValue()->gid; - to = Uint32::New(gid); - return scope.Close(to); + to = NanNew((uint32_t)gid); + NanReturnValue(to); } -Handle GitIndexEntry::FileSize(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::FileSize) { + NanScope(); Handle to; unsigned int file_size = ObjectWrap::Unwrap(args.This())->GetValue()->file_size; - to = Uint32::New(file_size); - return scope.Close(to); + to = NanNew((uint32_t)file_size); + NanReturnValue(to); } -Handle GitIndexEntry::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Oid) { + NanScope(); Handle to; git_oid *oid = @@ -189,42 +188,42 @@ Handle GitIndexEntry::Oid(const Arguments& args) { if (oid != NULL) { to = GitOid::New((void *)oid); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitIndexEntry::Flags(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Flags) { + NanScope(); Handle to; uint16_t flags = ObjectWrap::Unwrap(args.This())->GetValue()->flags; - to = Integer::New(flags); - return scope.Close(to); + to = NanNew(flags); + NanReturnValue(to); } -Handle GitIndexEntry::FlagsExtended(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::FlagsExtended) { + NanScope(); Handle to; uint16_t flags_extended = ObjectWrap::Unwrap(args.This())->GetValue()->flags_extended; - to = Integer::New(flags_extended); - return scope.Close(to); + to = NanNew(flags_extended); + NanReturnValue(to); } -Handle GitIndexEntry::Path(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexEntry::Path) { + NanScope(); Handle to; char * path = ObjectWrap::Unwrap(args.This())->GetValue()->path; - to = String::New(path); - return scope.Close(to); + to = NanNew(path); + NanReturnValue(to); } Persistent GitIndexEntry::constructor_template; diff --git a/src/index_time.cc b/src/index_time.cc index 5501bd61a..2da28c951 100644 --- a/src/index_time.cc +++ b/src/index_time.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,38 +22,38 @@ GitIndexTime::~GitIndexTime() { } void GitIndexTime::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("IndexTime")); + tpl->SetClassName(NanNew("IndexTime")); NODE_SET_PROTOTYPE_METHOD(tpl, "seconds", Seconds); NODE_SET_PROTOTYPE_METHOD(tpl, "nanoseconds", Nanoseconds); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("IndexTime"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("IndexTime"), _constructor_template); } -Handle GitIndexTime::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexTime::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_index_time is required."))); + return NanThrowError("git_index_time is required."); } - - GitIndexTime* object = new GitIndexTime((git_index_time *) External::Unwrap(args[0])); + GitIndexTime* object = new GitIndexTime(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitIndexTime::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitIndexTime::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitIndexTime::constructor_template)->NewInstance(1, argv)); } git_index_time *GitIndexTime::GetValue() { @@ -62,26 +61,26 @@ git_index_time *GitIndexTime::GetValue() { } -Handle GitIndexTime::Seconds(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexTime::Seconds) { + NanScope(); Handle to; git_time_t seconds = ObjectWrap::Unwrap(args.This())->GetValue()->seconds; - to = Uint32::New(seconds); - return scope.Close(to); + to = NanNew((uint32_t)seconds); + NanReturnValue(to); } -Handle GitIndexTime::Nanoseconds(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitIndexTime::Nanoseconds) { + NanScope(); Handle to; unsigned int nanoseconds = ObjectWrap::Unwrap(args.This())->GetValue()->nanoseconds; - to = Uint32::New(nanoseconds); - return scope.Close(to); + to = NanNew((uint32_t)nanoseconds); + NanReturnValue(to); } Persistent GitIndexTime::constructor_template; diff --git a/src/object.cc b/src/object.cc index be1895226..8a62b1300 100644 --- a/src/object.cc +++ b/src/object.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -25,39 +24,39 @@ GitObject::~GitObject() { } void GitObject::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Object")); + tpl->SetClassName(NanNew("Object")); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); NODE_SET_PROTOTYPE_METHOD(tpl, "type", Type); NODE_SET_PROTOTYPE_METHOD(tpl, "peel", Peel); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Object"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Object"), _constructor_template); } -Handle GitObject::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitObject::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_object is required."))); + return NanThrowError("git_object is required."); } - - GitObject* object = new GitObject((git_object *) External::Unwrap(args[0])); + GitObject* object = new GitObject(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitObject::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitObject::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitObject::constructor_template)->NewInstance(1, argv)); } git_object *GitObject::GetValue() { @@ -68,8 +67,8 @@ git_object *GitObject::GetValue() { /** * @return {Oid} result */ -Handle GitObject::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitObject::Oid) { + NanScope(); const git_oid * result = git_object_id( @@ -83,16 +82,16 @@ Handle GitObject::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitObject::Type(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitObject::Type) { + NanScope(); git_otype result = git_object_type( @@ -100,8 +99,8 @@ Handle GitObject::Type(const Arguments& args) { ); Handle to; - to = Number::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -110,35 +109,35 @@ Handle GitObject::Type(const Arguments& args) { * @param {Number} target_type * @param {Object} callback */ -Handle GitObject::Peel(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitObject::Peel) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number target_type is required."))); + return NanThrowError("Number target_type is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } PeelBaton* baton = new PeelBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->objectReference = Persistent::New(args.This()); baton->object = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->target_typeReference = Persistent::New(args[0]); git_otype from_target_type; from_target_type = (git_otype) args[0]->ToInt32()->Value(); baton->target_type = from_target_type; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, PeelWork, (uv_after_work_cb)PeelAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + PeelWorker *worker = new PeelWorker(baton, callback); + worker->SaveToPersistent("object", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("target_type", args[0]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitObject::PeelWork(uv_work_t *req) { - PeelBaton *baton = static_cast(req->data); +void GitObject::PeelWorker::Execute() { int result = git_object_peel( &baton->peeled, baton->object, @@ -150,44 +149,38 @@ void GitObject::PeelWork(uv_work_t *req) { } } -void GitObject::PeelAfterWork(uv_work_t *req) { - HandleScope scope; - PeelBaton *baton = static_cast(req->data); - +void GitObject::PeelWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->peeled != NULL) { to = GitObject::New((void *)baton->peeled); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->objectReference.Dispose(); - baton->target_typeReference.Dispose(); - baton->callback.Dispose(); delete baton; } diff --git a/src/odb.cc b/src/odb.cc index 0ed9b605f..c45ce17c8 100644 --- a/src/odb.cc +++ b/src/odb.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -26,12 +25,12 @@ GitOdb::~GitOdb() { } void GitOdb::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Odb")); + tpl->SetClassName(NanNew("Odb")); NODE_SET_METHOD(tpl, "create()", Create); NODE_SET_METHOD(tpl, "open", Open); @@ -46,27 +45,27 @@ void GitOdb::Initialize(Handle target) { NODE_SET_METHOD(tpl, "hashfile", Hashfile); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Odb"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Odb"), _constructor_template); } -Handle GitOdb::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_odb is required."))); + return NanThrowError("git_odb is required."); } - - GitOdb* object = new GitOdb((git_odb *) External::Unwrap(args[0])); + GitOdb* object = new GitOdb(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitOdb::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitOdb::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitOdb::constructor_template)->NewInstance(1, argv)); } git_odb *GitOdb::GetValue() { @@ -77,8 +76,8 @@ git_odb *GitOdb::GetValue() { /** * @return {Odb} out */ -Handle GitOdb::Create(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Create) { + NanScope(); git_odb * out = 0; @@ -87,9 +86,9 @@ Handle GitOdb::Create(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -97,19 +96,19 @@ Handle GitOdb::Create(const Arguments& args) { if (out != NULL) { to = GitOdb::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {String} objects_dir * @return {Odb} out */ -Handle GitOdb::Open(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Open) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String objects_dir is required."))); + return NanThrowError("String objects_dir is required."); } git_odb * out = 0; @@ -124,9 +123,9 @@ Handle GitOdb::Open(const Arguments& args) { free((void *)from_objects_dir); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -134,18 +133,18 @@ Handle GitOdb::Open(const Arguments& args) { if (out != NULL) { to = GitOdb::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {String} path */ -Handle GitOdb::AddDiskAlternate(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::AddDiskAlternate) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } const char * from_path; @@ -159,13 +158,13 @@ Handle GitOdb::AddDiskAlternate(const Arguments& args) { free((void *)from_path); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" @@ -174,35 +173,35 @@ Handle GitOdb::AddDiskAlternate(const Arguments& args) { * @param {Oid} id * @param {OdbObject} callback */ -Handle GitOdb::Read(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Read) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ReadBaton* baton = new ReadBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->dbReference = Persistent::New(args.This()); baton->db = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, ReadWork, (uv_after_work_cb)ReadAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + ReadWorker *worker = new ReadWorker(baton, callback); + worker->SaveToPersistent("db", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitOdb::ReadWork(uv_work_t *req) { - ReadBaton *baton = static_cast(req->data); +void GitOdb::ReadWorker::Execute() { int result = git_odb_read( &baton->out, baton->db, @@ -214,44 +213,38 @@ void GitOdb::ReadWork(uv_work_t *req) { } } -void GitOdb::ReadAfterWork(uv_work_t *req) { - HandleScope scope; - ReadBaton *baton = static_cast(req->data); - +void GitOdb::ReadWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitOdbObject::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->dbReference.Dispose(); - baton->idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -261,16 +254,16 @@ void GitOdb::ReadAfterWork(uv_work_t *req) { * @param {Number} len * @return {OdbObject} out */ -Handle GitOdb::ReadPrefix(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::ReadPrefix) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Odb db is required."))); + return NanThrowError("Odb db is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid short_id is required."))); + return NanThrowError("Oid short_id is required."); } if (args.Length() == 2 || !args[2]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number len is required."))); + return NanThrowError("Number len is required."); } git_odb_object * out = 0; @@ -289,9 +282,9 @@ Handle GitOdb::ReadPrefix(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -299,9 +292,9 @@ Handle GitOdb::ReadPrefix(const Arguments& args) { if (out != NULL) { to = GitOdbObject::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -310,13 +303,13 @@ Handle GitOdb::ReadPrefix(const Arguments& args) { * @return {Number} len_out * @return {Number} type_out */ -Handle GitOdb::ReadHeader(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::ReadHeader) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Odb db is required."))); + return NanThrowError("Odb db is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } size_t len_out = 0; @@ -334,30 +327,30 @@ Handle GitOdb::ReadHeader(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - Handle toReturn = Object::New(); + Handle toReturn = NanNew(); Handle to; - to = Uint32::New(len_out); - toReturn->Set(String::NewSymbol("len_out"), to); + to = NanNew((uint32_t)len_out); + toReturn->Set(NanNew("len_out"), to); - to = Int32::New(type_out); - toReturn->Set(String::NewSymbol("type_out"), to); + to = NanNew((int32_t)type_out); + toReturn->Set(NanNew("type_out"), to); - return scope.Close(toReturn); + NanReturnValue(toReturn); } /** * @param {Oid} id */ -Handle GitOdb::Exists(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Exists) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } const git_oid * from_id; @@ -369,19 +362,19 @@ Handle GitOdb::Exists(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** */ -Handle GitOdb::Refresh(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Refresh) { + NanScope(); int result = git_odb_refresh( @@ -389,13 +382,13 @@ Handle GitOdb::Refresh(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" @@ -406,51 +399,53 @@ Handle GitOdb::Refresh(const Arguments& args) { * @param {Number} type * @param {Oid} callback */ -Handle GitOdb::Write(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Write) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String data is required."))); + return NanThrowError("String data is required."); } if (args.Length() == 1 || !args[1]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number len is required."))); + return NanThrowError("Number len is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number type is required."))); + return NanThrowError("Number type is required."); } if (args.Length() == 3 || !args[3]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } WriteBaton* baton = new WriteBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->out = (git_oid *)malloc(sizeof(git_oid )); - baton->odbReference = Persistent::New(args.This()); baton->odb = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->dataReference = Persistent::New(args[0]); const void * from_data; String::Utf8Value data(args[0]->ToString()); from_data = strdup(*data); baton->data = from_data; - baton->lenReference = Persistent::New(args[1]); - size_t from_len; + size_t from_len; from_len = (size_t) args[1]->ToUint32()->Value(); baton->len = from_len; - baton->typeReference = Persistent::New(args[2]); - git_otype from_type; + git_otype from_type; from_type = (git_otype) args[2]->ToInt32()->Value(); baton->type = from_type; - baton->callback = Persistent::New(Local::Cast(args[3])); - - uv_queue_work(uv_default_loop(), &baton->request, WriteWork, (uv_after_work_cb)WriteAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[3])); + WriteWorker *worker = new WriteWorker(baton, callback); + worker->SaveToPersistent("odb", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("data", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("len", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("type", args[2]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitOdb::WriteWork(uv_work_t *req) { - WriteBaton *baton = static_cast(req->data); +void GitOdb::WriteWorker::Execute() { int result = git_odb_write( baton->out, baton->odb, @@ -464,35 +459,32 @@ void GitOdb::WriteWork(uv_work_t *req) { } } -void GitOdb::WriteAfterWork(uv_work_t *req) { - HandleScope scope; - WriteBaton *baton = static_cast(req->data); - +void GitOdb::WriteWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitOid::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->out); } @@ -500,11 +492,6 @@ void GitOdb::WriteAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->odbReference.Dispose(); - baton->dataReference.Dispose(); - baton->lenReference.Dispose(); - baton->typeReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->data); delete baton; } @@ -515,16 +502,16 @@ void GitOdb::WriteAfterWork(uv_work_t *req) { * @param {Number} type * @return {Oid} out */ -Handle GitOdb::Hash(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Hash) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Buffer data is required."))); + return NanThrowError("Buffer data is required."); } if (args.Length() == 1 || !args[1]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number len is required."))); + return NanThrowError("Number len is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number type is required."))); + return NanThrowError("Number type is required."); } git_oid *out = (git_oid *)malloc(sizeof(git_oid)); @@ -544,9 +531,9 @@ Handle GitOdb::Hash(const Arguments& args) { if (result != GIT_OK) { free(out); if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -554,9 +541,9 @@ Handle GitOdb::Hash(const Arguments& args) { if (out != NULL) { to = GitOid::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -564,13 +551,13 @@ Handle GitOdb::Hash(const Arguments& args) { * @param {Number} type * @return {Oid} out */ -Handle GitOdb::Hashfile(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdb::Hashfile) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number type is required."))); + return NanThrowError("Number type is required."); } git_oid *out = (git_oid *)malloc(sizeof(git_oid)); @@ -589,9 +576,9 @@ Handle GitOdb::Hashfile(const Arguments& args) { if (result != GIT_OK) { free(out); if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -599,9 +586,9 @@ Handle GitOdb::Hashfile(const Arguments& args) { if (out != NULL) { to = GitOid::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } Persistent GitOdb::constructor_template; diff --git a/src/odb_object.cc b/src/odb_object.cc index 507d63736..2316738fe 100644 --- a/src/odb_object.cc +++ b/src/odb_object.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -25,12 +24,12 @@ GitOdbObject::~GitOdbObject() { } void GitOdbObject::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("OdbObject")); + tpl->SetClassName(NanNew("OdbObject")); NODE_SET_PROTOTYPE_METHOD(tpl, "data", Data); NODE_SET_PROTOTYPE_METHOD(tpl, "size", Size); @@ -38,27 +37,27 @@ void GitOdbObject::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("OdbObject"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("OdbObject"), _constructor_template); } -Handle GitOdbObject::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdbObject::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_odb_object is required."))); + return NanThrowError("git_odb_object is required."); } - - GitOdbObject* object = new GitOdbObject((git_odb_object *) External::Unwrap(args[0])); + GitOdbObject* object = new GitOdbObject(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitOdbObject::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitOdbObject::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitOdbObject::constructor_template)->NewInstance(1, argv)); } git_odb_object *GitOdbObject::GetValue() { @@ -69,8 +68,8 @@ git_odb_object *GitOdbObject::GetValue() { /** * @return {Wrapper} result */ -Handle GitOdbObject::Data(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdbObject::Data) { + NanScope(); const void * result = git_odb_object_data( @@ -81,16 +80,16 @@ Handle GitOdbObject::Data(const Arguments& args) { if (result != NULL) { to = Wrapper::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitOdbObject::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdbObject::Size) { + NanScope(); size_t result = git_odb_object_size( @@ -98,15 +97,15 @@ Handle GitOdbObject::Size(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitOdbObject::Type(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdbObject::Type) { + NanScope(); git_otype result = git_odb_object_type( @@ -114,15 +113,15 @@ Handle GitOdbObject::Type(const Arguments& args) { ); Handle to; - to = Int32::New(result); - return scope.Close(to); + to = NanNew((int32_t)result); + NanReturnValue(to); } /** * @return {Oid} result */ -Handle GitOdbObject::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOdbObject::Oid) { + NanScope(); const git_oid * result = git_odb_object_id( @@ -136,9 +135,9 @@ Handle GitOdbObject::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } Persistent GitOdbObject::constructor_template; diff --git a/src/oid.cc b/src/oid.cc index 0f354998f..e05f9400b 100755 --- a/src/oid.cc +++ b/src/oid.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,38 +22,38 @@ GitOid::~GitOid() { } void GitOid::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Oid")); + tpl->SetClassName(NanNew("Oid")); NODE_SET_METHOD(tpl, "fromString", FromString); NODE_SET_PROTOTYPE_METHOD(tpl, "sha", Sha); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Oid"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Oid"), _constructor_template); } -Handle GitOid::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOid::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_oid is required."))); + return NanThrowError("git_oid is required."); } - - GitOid* object = new GitOid((git_oid *) External::Unwrap(args[0])); + GitOid* object = new GitOid(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitOid::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitOid::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitOid::constructor_template)->NewInstance(1, argv)); } git_oid *GitOid::GetValue() { @@ -66,10 +65,10 @@ git_oid *GitOid::GetValue() { * @param {String} str * @return {Oid} out */ -Handle GitOid::FromString(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOid::FromString) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String str is required."))); + return NanThrowError("String str is required."); } git_oid *out = (git_oid *)malloc(sizeof(git_oid)); @@ -85,9 +84,9 @@ Handle GitOid::FromString(const Arguments& args) { if (result != GIT_OK) { free(out); if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -95,16 +94,16 @@ Handle GitOid::FromString(const Arguments& args) { if (out != NULL) { to = GitOid::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitOid::Sha(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitOid::Sha) { + NanScope(); char * result = git_oid_allocfmt( @@ -112,9 +111,9 @@ Handle GitOid::Sha(const Arguments& args) { ); Handle to; - to = String::New(result); + to = NanNew(result); free(result); - return scope.Close(to); + NanReturnValue(to); } Persistent GitOid::constructor_template; diff --git a/src/patch.cc b/src/patch.cc index ce5e9d90f..936f2d3e6 100644 --- a/src/patch.cc +++ b/src/patch.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -25,12 +24,12 @@ GitPatch::~GitPatch() { } void GitPatch::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Patch")); + tpl->SetClassName(NanNew("Patch")); NODE_SET_PROTOTYPE_METHOD(tpl, "delta", Delta); NODE_SET_PROTOTYPE_METHOD(tpl, "size", Size); @@ -41,27 +40,27 @@ void GitPatch::Initialize(Handle target) { NODE_SET_METHOD(tpl, "toString", ToString); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Patch"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Patch"), _constructor_template); } -Handle GitPatch::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_diff_patch is required."))); + return NanThrowError("git_diff_patch is required."); } - - GitPatch* object = new GitPatch((git_diff_patch *) External::Unwrap(args[0])); + GitPatch* object = new GitPatch(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitPatch::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitPatch::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitPatch::constructor_template)->NewInstance(1, argv)); } git_diff_patch *GitPatch::GetValue() { @@ -72,8 +71,8 @@ git_diff_patch *GitPatch::GetValue() { /** * @return {Delta} result */ -Handle GitPatch::Delta(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::Delta) { + NanScope(); const git_diff_delta * result = git_diff_patch_delta( @@ -87,16 +86,16 @@ Handle GitPatch::Delta(const Arguments& args) { if (result != NULL) { to = GitDelta::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitPatch::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::Size) { + NanScope(); size_t result = git_diff_patch_num_hunks( @@ -104,8 +103,8 @@ Handle GitPatch::Size(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** @@ -113,8 +112,8 @@ Handle GitPatch::Size(const Arguments& args) { * @return {Number} total_additions * @return {Number} total_deletions */ -Handle GitPatch::Stats(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::Stats) { + NanScope(); size_t total_context = 0; size_t total_additions = 0; @@ -128,24 +127,24 @@ Handle GitPatch::Stats(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - Handle toReturn = Object::New(); + Handle toReturn = NanNew(); Handle to; - to = Integer::New(total_context); - toReturn->Set(String::NewSymbol("total_context"), to); + to = NanNew(total_context); + toReturn->Set(NanNew("total_context"), to); - to = Integer::New(total_additions); - toReturn->Set(String::NewSymbol("total_additions"), to); + to = NanNew(total_additions); + toReturn->Set(NanNew("total_additions"), to); - to = Integer::New(total_deletions); - toReturn->Set(String::NewSymbol("total_deletions"), to); + to = NanNew(total_deletions); + toReturn->Set(NanNew("total_deletions"), to); - return scope.Close(toReturn); + NanReturnValue(toReturn); } /** @@ -155,10 +154,10 @@ Handle GitPatch::Stats(const Arguments& args) { * @return {Number} header_len * @return {Number} lines_in_hunk */ -Handle GitPatch::Hunk(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::Hunk) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number hunk_idx is required."))); + return NanThrowError("Number hunk_idx is required."); } const git_diff_range * range = 0; @@ -178,13 +177,13 @@ Handle GitPatch::Hunk(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - Handle toReturn = Object::New(); + Handle toReturn = NanNew(); Handle to; if (range != NULL) { range = (const git_diff_range * )git_diff_range_dup(range); @@ -192,30 +191,30 @@ Handle GitPatch::Hunk(const Arguments& args) { if (range != NULL) { to = GitDiffRange::New((void *)range); } else { - to = Null(); + to = NanNull(); } - toReturn->Set(String::NewSymbol("range"), to); + toReturn->Set(NanNew("range"), to); - to = String::New(header); - toReturn->Set(String::NewSymbol("header"), to); + to = NanNew(header); + toReturn->Set(NanNew("header"), to); - to = Uint32::New(header_len); - toReturn->Set(String::NewSymbol("headerLength"), to); + to = NanNew((uint32_t)header_len); + toReturn->Set(NanNew("headerLength"), to); - to = Uint32::New(lines_in_hunk); - toReturn->Set(String::NewSymbol("lines"), to); + to = NanNew((uint32_t)lines_in_hunk); + toReturn->Set(NanNew("lines"), to); - return scope.Close(toReturn); + NanReturnValue(toReturn); } /** * @param {Number} hunk_idx * @return {Number} result */ -Handle GitPatch::Lines(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::Lines) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number hunk_idx is required."))); + return NanThrowError("Number hunk_idx is required."); } size_t from_hunk_idx; @@ -227,8 +226,8 @@ Handle GitPatch::Lines(const Arguments& args) { ); Handle to; - to = Int32::New(result); - return scope.Close(to); + to = NanNew((int32_t)result); + NanReturnValue(to); } /** @@ -240,13 +239,13 @@ Handle GitPatch::Lines(const Arguments& args) { * @return {Number} old_lineno * @return {Number} new_lineno */ -Handle GitPatch::Line(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::Line) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number hunk_idx is required."))); + return NanThrowError("Number hunk_idx is required."); } if (args.Length() == 1 || !args[1]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number line_of_hunk is required."))); + return NanThrowError("Number line_of_hunk is required."); } char line_origin = 0; @@ -271,37 +270,37 @@ Handle GitPatch::Line(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - Handle toReturn = Object::New(); + Handle toReturn = NanNew(); Handle to; - to = Integer::New(line_origin); - toReturn->Set(String::NewSymbol("lineOrigin"), to); + to = NanNew(line_origin); + toReturn->Set(NanNew("lineOrigin"), to); - to = String::New(content, content_len); - toReturn->Set(String::NewSymbol("content"), to); + to = NanNew(content, content_len); + toReturn->Set(NanNew("content"), to); - to = Uint32::New(content_len); - toReturn->Set(String::NewSymbol("length"), to); + to = NanNew((uint32_t)content_len); + toReturn->Set(NanNew("length"), to); - to = Int32::New(old_lineno); - toReturn->Set(String::NewSymbol("oldLineNumber"), to); + to = NanNew((int32_t)old_lineno); + toReturn->Set(NanNew("oldLineNumber"), to); - to = Int32::New(new_lineno); - toReturn->Set(String::NewSymbol("newLineNumber"), to); + to = NanNew((int32_t)new_lineno); + toReturn->Set(NanNew("newLineNumber"), to); - return scope.Close(toReturn); + NanReturnValue(toReturn); } /** * @return {String} string */ -Handle GitPatch::ToString(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitPatch::ToString) { + NanScope(); char * string = 0; @@ -311,16 +310,16 @@ Handle GitPatch::ToString(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } Handle to; - to = String::New(string); + to = NanNew(string); free(string); - return scope.Close(to); + NanReturnValue(to); } Persistent GitPatch::constructor_template; diff --git a/src/refdb.cc b/src/refdb.cc index d1b344d76..b9279d17f 100644 --- a/src/refdb.cc +++ b/src/refdb.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,36 +22,36 @@ GitRefDb::~GitRefDb() { } void GitRefDb::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("RefDb")); + tpl->SetClassName(NanNew("RefDb")); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("RefDb"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("RefDb"), _constructor_template); } -Handle GitRefDb::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRefDb::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_refdb is required."))); + return NanThrowError("git_refdb is required."); } - - GitRefDb* object = new GitRefDb((git_refdb *) External::Unwrap(args[0])); + GitRefDb* object = new GitRefDb(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitRefDb::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitRefDb::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitRefDb::constructor_template)->NewInstance(1, argv)); } git_refdb *GitRefDb::GetValue() { diff --git a/src/reference.cc b/src/reference.cc index 53a666230..131df574a 100755 --- a/src/reference.cc +++ b/src/reference.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -26,12 +25,12 @@ GitReference::~GitReference() { } void GitReference::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Reference")); + tpl->SetClassName(NanNew("Reference")); NODE_SET_METHOD(tpl, "oidForName", OidForName); NODE_SET_PROTOTYPE_METHOD(tpl, "target", Target); @@ -49,27 +48,27 @@ void GitReference::Initialize(Handle target) { NODE_SET_METHOD(tpl, "isValidName", IsValidName); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Reference"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Reference"), _constructor_template); } -Handle GitReference::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_reference is required."))); + return NanThrowError("git_reference is required."); } - - GitReference* object = new GitReference((git_reference *) External::Unwrap(args[0])); + GitReference* object = new GitReference(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitReference::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitReference::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitReference::constructor_template)->NewInstance(1, argv)); } git_reference *GitReference::GetValue() { @@ -84,42 +83,43 @@ git_reference *GitReference::GetValue() { * @param {String} name * @param {Oid} callback */ -Handle GitReference::OidForName(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::OidForName) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } OidForNameBaton* baton = new OidForNameBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->out = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->nameReference = Persistent::New(args[1]); - const char * from_name; + const char * from_name; String::Utf8Value name(args[1]->ToString()); from_name = strdup(*name); baton->name = from_name; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, OidForNameWork, (uv_after_work_cb)OidForNameAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + OidForNameWorker *worker = new OidForNameWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("name", args[1]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitReference::OidForNameWork(uv_work_t *req) { - OidForNameBaton *baton = static_cast(req->data); +void GitReference::OidForNameWorker::Execute() { int result = git_reference_name_to_id( baton->out, baton->repo, @@ -131,35 +131,32 @@ void GitReference::OidForNameWork(uv_work_t *req) { } } -void GitReference::OidForNameAfterWork(uv_work_t *req) { - HandleScope scope; - OidForNameBaton *baton = static_cast(req->data); - +void GitReference::OidForNameWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitOid::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->out); } @@ -167,9 +164,6 @@ void GitReference::OidForNameAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->nameReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->name); delete baton; } @@ -177,8 +171,8 @@ void GitReference::OidForNameAfterWork(uv_work_t *req) { /** * @return {Oid} result */ -Handle GitReference::Target(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Target) { + NanScope(); const git_oid * result = git_reference_target( @@ -192,16 +186,16 @@ Handle GitReference::Target(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitReference::SymbolicTarget(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::SymbolicTarget) { + NanScope(); const char * result = git_reference_symbolic_target( @@ -209,15 +203,15 @@ Handle GitReference::SymbolicTarget(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitReference::Type(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Type) { + NanScope(); git_ref_t result = git_reference_type( @@ -225,15 +219,15 @@ Handle GitReference::Type(const Arguments& args) { ); Handle to; - to = Number::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitReference::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Name) { + NanScope(); const char * result = git_reference_name( @@ -241,8 +235,8 @@ Handle GitReference::Name(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -250,28 +244,27 @@ Handle GitReference::Name(const Arguments& args) { /** * @param {Reference} callback */ -Handle GitReference::Resolve(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Resolve) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ResolveBaton* baton = new ResolveBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->refReference = Persistent::New(args.This()); baton->ref = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, ResolveWork, (uv_after_work_cb)ResolveAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + ResolveWorker *worker = new ResolveWorker(baton, callback); + worker->SaveToPersistent("ref", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitReference::ResolveWork(uv_work_t *req) { - ResolveBaton *baton = static_cast(req->data); +void GitReference::ResolveWorker::Execute() { int result = git_reference_resolve( &baton->out, baton->ref @@ -282,43 +275,38 @@ void GitReference::ResolveWork(uv_work_t *req) { } } -void GitReference::ResolveAfterWork(uv_work_t *req) { - HandleScope scope; - ResolveBaton *baton = static_cast(req->data); - +void GitReference::ResolveWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitReference::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->refReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -326,10 +314,10 @@ void GitReference::ResolveAfterWork(uv_work_t *req) { * @param {String} target * @return {Reference} out */ -Handle GitReference::SetSymbolicTarget(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::SetSymbolicTarget) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String target is required."))); + return NanThrowError("String target is required."); } git_reference * out = 0; @@ -345,9 +333,9 @@ Handle GitReference::SetSymbolicTarget(const Arguments& args) { free((void *)from_target); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -355,19 +343,19 @@ Handle GitReference::SetSymbolicTarget(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Oid} id * @return {Reference} out */ -Handle GitReference::setTarget(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::setTarget) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } git_reference * out = 0; @@ -381,9 +369,9 @@ Handle GitReference::setTarget(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -391,9 +379,9 @@ Handle GitReference::setTarget(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -403,43 +391,44 @@ Handle GitReference::setTarget(const Arguments& args) { * @param {Number} force * @param {Reference} callback */ -Handle GitReference::Rename(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Rename) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String new_name is required."))); + return NanThrowError("String new_name is required."); } if (args.Length() == 1 || !args[1]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } RenameBaton* baton = new RenameBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->refReference = Persistent::New(args.This()); baton->ref = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->new_nameReference = Persistent::New(args[0]); const char * from_new_name; String::Utf8Value new_name(args[0]->ToString()); from_new_name = strdup(*new_name); baton->new_name = from_new_name; - baton->forceReference = Persistent::New(args[1]); - int from_force; + int from_force; from_force = (int) args[1]->ToInt32()->Value(); baton->force = from_force; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, RenameWork, (uv_after_work_cb)RenameAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + RenameWorker *worker = new RenameWorker(baton, callback); + worker->SaveToPersistent("ref", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("new_name", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("force", args[1]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitReference::RenameWork(uv_work_t *req) { - RenameBaton *baton = static_cast(req->data); +void GitReference::RenameWorker::Execute() { int result = git_reference_rename( &baton->out, baton->ref, @@ -452,45 +441,38 @@ void GitReference::RenameWork(uv_work_t *req) { } } -void GitReference::RenameAfterWork(uv_work_t *req) { - HandleScope scope; - RenameBaton *baton = static_cast(req->data); - +void GitReference::RenameWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitReference::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->refReference.Dispose(); - baton->new_nameReference.Dispose(); - baton->forceReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->new_name); delete baton; } @@ -499,28 +481,27 @@ void GitReference::RenameAfterWork(uv_work_t *req) { /** */ -Handle GitReference::Delete(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Delete) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DeleteBaton* baton = new DeleteBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->refReference = Persistent::New(args.This()); baton->ref = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, DeleteWork, (uv_after_work_cb)DeleteAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + DeleteWorker *worker = new DeleteWorker(baton, callback); + worker->SaveToPersistent("ref", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitReference::DeleteWork(uv_work_t *req) { - DeleteBaton *baton = static_cast(req->data); +void GitReference::DeleteWorker::Execute() { int result = git_reference_delete( baton->ref ); @@ -530,44 +511,39 @@ void GitReference::DeleteWork(uv_work_t *req) { } } -void GitReference::DeleteAfterWork(uv_work_t *req) { - HandleScope scope; - DeleteBaton *baton = static_cast(req->data); - +void GitReference::DeleteWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->refReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** */ -Handle GitReference::IsBranch(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::IsBranch) { + NanScope(); int result = git_reference_is_branch( @@ -575,19 +551,19 @@ Handle GitReference::IsBranch(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** */ -Handle GitReference::IsRemote(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::IsRemote) { + NanScope(); int result = git_reference_is_remote( @@ -595,23 +571,23 @@ Handle GitReference::IsRemote(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {Number} type * @return {Object} out */ -Handle GitReference::Peel(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::Peel) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number type is required."))); + return NanThrowError("Number type is required."); } git_object * out = 0; @@ -625,9 +601,9 @@ Handle GitReference::Peel(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -635,18 +611,18 @@ Handle GitReference::Peel(const Arguments& args) { if (out != NULL) { to = GitObject::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {String} refname */ -Handle GitReference::IsValidName(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitReference::IsValidName) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String refname is required."))); + return NanThrowError("String refname is required."); } const char * from_refname; @@ -659,13 +635,13 @@ Handle GitReference::IsValidName(const Arguments& args) { free((void *)from_refname); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } Persistent GitReference::constructor_template; diff --git a/src/remote.cc b/src/remote.cc index c0fd95a6b..4f6c33b1b 100644 --- a/src/remote.cc +++ b/src/remote.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -24,12 +23,12 @@ GitRemote::~GitRemote() { } void GitRemote::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Remote")); + tpl->SetClassName(NanNew("Remote")); NODE_SET_PROTOTYPE_METHOD(tpl, "name", Name); NODE_SET_PROTOTYPE_METHOD(tpl, "url", Url); @@ -50,27 +49,27 @@ void GitRemote::Initialize(Handle target) { NODE_SET_METHOD(tpl, "isValidName", IsValidName); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Remote"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Remote"), _constructor_template); } -Handle GitRemote::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_remote is required."))); + return NanThrowError("git_remote is required."); } - - GitRemote* object = new GitRemote((git_remote *) External::Unwrap(args[0])); + GitRemote* object = new GitRemote(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitRemote::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitRemote::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitRemote::constructor_template)->NewInstance(1, argv)); } git_remote *GitRemote::GetValue() { @@ -81,8 +80,8 @@ git_remote *GitRemote::GetValue() { /** * @return {String} result */ -Handle GitRemote::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Name) { + NanScope(); const char * result = git_remote_name( @@ -90,15 +89,15 @@ Handle GitRemote::Name(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitRemote::Url(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Url) { + NanScope(); const char * result = git_remote_url( @@ -106,15 +105,15 @@ Handle GitRemote::Url(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitRemote::PushUrl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::PushUrl) { + NanScope(); const char * result = git_remote_pushurl( @@ -122,17 +121,17 @@ Handle GitRemote::PushUrl(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @param {String} url */ -Handle GitRemote::SetUrl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::SetUrl) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } const char* from_url; @@ -146,22 +145,22 @@ Handle GitRemote::SetUrl(const Arguments& args) { free((void *)from_url); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {String} url */ -Handle GitRemote::SetPushUrl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::SetPushUrl) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } const char* from_url; @@ -175,13 +174,13 @@ Handle GitRemote::SetPushUrl(const Arguments& args) { free((void *)from_url); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" @@ -189,35 +188,35 @@ Handle GitRemote::SetPushUrl(const Arguments& args) { /** * @param {Number} direction */ -Handle GitRemote::Connect(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Connect) { + NanScope(); if (args.Length() == 0 || !args[0]->IsNumber()) { - return ThrowException(Exception::Error(String::New("Number direction is required."))); + return NanThrowError("Number direction is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ConnectBaton* baton = new ConnectBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->remoteReference = Persistent::New(args.This()); baton->remote = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->directionReference = Persistent::New(args[0]); git_direction from_direction; from_direction = (git_direction) (int) args[0]->ToNumber()->Value(); baton->direction = from_direction; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, ConnectWork, (uv_after_work_cb)ConnectAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + ConnectWorker *worker = new ConnectWorker(baton, callback); + worker->SaveToPersistent("remote", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("direction", args[0]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRemote::ConnectWork(uv_work_t *req) { - ConnectBaton *baton = static_cast(req->data); +void GitRemote::ConnectWorker::Execute() { int result = git_remote_connect( baton->remote, baton->direction @@ -228,38 +227,32 @@ void GitRemote::ConnectWork(uv_work_t *req) { } } -void GitRemote::ConnectAfterWork(uv_work_t *req) { - HandleScope scope; - ConnectBaton *baton = static_cast(req->data); - +void GitRemote::ConnectWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->remoteReference.Dispose(); - baton->directionReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -269,37 +262,37 @@ void GitRemote::ConnectAfterWork(uv_work_t *req) { * @param {Function} progress_cb * @param {void} payload */ -Handle GitRemote::Download(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Download) { + NanScope(); if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DownloadBaton* baton = new DownloadBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->remoteReference = Persistent::New(args.This()); baton->remote = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->progress_cbReference = Persistent::New(args[0]); git_transfer_progress_callback from_progress_cb; if (args[0]->IsFunction()) { - Persistent::New(Local::Cast(args[0])); - } else { + } else { from_progress_cb = 0; } baton->progress_cb = from_progress_cb; - baton->payloadReference = Persistent::New(args[1]); - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, DownloadWork, (uv_after_work_cb)DownloadAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + DownloadWorker *worker = new DownloadWorker(baton, callback); + worker->SaveToPersistent("remote", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("progress_cb", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("payload", args[1]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRemote::DownloadWork(uv_work_t *req) { - DownloadBaton *baton = static_cast(req->data); +void GitRemote::DownloadWorker::Execute() { int result = git_remote_download( baton->remote, baton->progress_cb, @@ -311,46 +304,39 @@ void GitRemote::DownloadWork(uv_work_t *req) { } } -void GitRemote::DownloadAfterWork(uv_work_t *req) { - HandleScope scope; - DownloadBaton *baton = static_cast(req->data); - +void GitRemote::DownloadWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->remoteReference.Dispose(); - baton->progress_cbReference.Dispose(); - baton->payloadReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** */ -Handle GitRemote::Connected(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Connected) { + NanScope(); int result = git_remote_connected( @@ -358,97 +344,91 @@ Handle GitRemote::Connected(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** */ -Handle GitRemote::Stop(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Stop) { + NanScope(); git_remote_stop( ObjectWrap::Unwrap(args.This())->GetValue() ); - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" /** */ -Handle GitRemote::Disconnect(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::Disconnect) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DisconnectBaton* baton = new DisconnectBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->remoteReference = Persistent::New(args.This()); baton->remote = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, DisconnectWork, (uv_after_work_cb)DisconnectAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + DisconnectWorker *worker = new DisconnectWorker(baton, callback); + worker->SaveToPersistent("remote", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRemote::DisconnectWork(uv_work_t *req) { - DisconnectBaton *baton = static_cast(req->data); +void GitRemote::DisconnectWorker::Execute() { git_remote_disconnect( baton->remote ); } -void GitRemote::DisconnectAfterWork(uv_work_t *req) { - HandleScope scope; - DisconnectBaton *baton = static_cast(req->data); - +void GitRemote::DisconnectWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->remoteReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** */ -Handle GitRemote::UpdateTips(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::UpdateTips) { + NanScope(); int result = git_remote_update_tips( @@ -456,22 +436,22 @@ Handle GitRemote::UpdateTips(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {String} url */ -Handle GitRemote::ValidUrl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::ValidUrl) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } const char * from_url; @@ -484,22 +464,22 @@ Handle GitRemote::ValidUrl(const Arguments& args) { free((void *)from_url); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {String} url */ -Handle GitRemote::SupportedUrl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::SupportedUrl) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } const char* from_url; @@ -512,22 +492,22 @@ Handle GitRemote::SupportedUrl(const Arguments& args) { free((void *)from_url); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {Number} check */ -Handle GitRemote::CheckCert(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::CheckCert) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number check is required."))); + return NanThrowError("Number check is required."); } int from_check; @@ -538,13 +518,13 @@ Handle GitRemote::CheckCert(const Arguments& args) { , from_check ); - return Undefined(); + NanReturnUndefined(); } /** */ -Handle GitRemote::UpdateFetchhead(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::UpdateFetchhead) { + NanScope(); int result = git_remote_update_fetchhead( @@ -552,22 +532,22 @@ Handle GitRemote::UpdateFetchhead(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @param {Number} value */ -Handle GitRemote::SetUpdateFetchhead(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::SetUpdateFetchhead) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number value is required."))); + return NanThrowError("Number value is required."); } int from_value; @@ -578,16 +558,16 @@ Handle GitRemote::SetUpdateFetchhead(const Arguments& args) { , from_value ); - return Undefined(); + NanReturnUndefined(); } /** * @param {String} remote_name */ -Handle GitRemote::IsValidName(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRemote::IsValidName) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String remote_name is required."))); + return NanThrowError("String remote_name is required."); } const char * from_remote_name; @@ -600,13 +580,13 @@ Handle GitRemote::IsValidName(const Arguments& args) { free((void *)from_remote_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } Persistent GitRemote::constructor_template; diff --git a/src/repo.cc b/src/repo.cc index 637479573..0e46f91d2 100755 --- a/src/repo.cc +++ b/src/repo.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -39,12 +38,12 @@ GitRepo::~GitRepo() { } void GitRepo::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Repo")); + tpl->SetClassName(NanNew("Repo")); NODE_SET_METHOD(tpl, "open", Open); NODE_SET_METHOD(tpl, "init", Init); @@ -77,27 +76,27 @@ void GitRepo::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "getRemote", GetRemote); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Repo"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Repo"), _constructor_template); } -Handle GitRepo::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_repository is required."))); + return NanThrowError("git_repository is required."); } - - GitRepo* object = new GitRepo((git_repository *) External::Unwrap(args[0])); + GitRepo* object = new GitRepo(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitRepo::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitRepo::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitRepo::constructor_template)->NewInstance(1, argv)); } git_repository *GitRepo::GetValue() { @@ -111,34 +110,34 @@ git_repository *GitRepo::GetValue() { * @param {String} path * @param {Repository} callback */ -Handle GitRepo::Open(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Open) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } OpenBaton* baton = new OpenBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->pathReference = Persistent::New(args[0]); const char * from_path; String::Utf8Value path(args[0]->ToString()); from_path = strdup(*path); baton->path = from_path; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, OpenWork, (uv_after_work_cb)OpenAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + OpenWorker *worker = new OpenWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("path", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::OpenWork(uv_work_t *req) { - OpenBaton *baton = static_cast(req->data); +void GitRepo::OpenWorker::Execute() { int result = git_repository_open( &baton->out, baton->path @@ -149,43 +148,38 @@ void GitRepo::OpenWork(uv_work_t *req) { } } -void GitRepo::OpenAfterWork(uv_work_t *req) { - HandleScope scope; - OpenBaton *baton = static_cast(req->data); - +void GitRepo::OpenWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitRepo::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->pathReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->path); delete baton; } @@ -197,41 +191,42 @@ void GitRepo::OpenAfterWork(uv_work_t *req) { * @param {Boolean} is_bare * @param {Repository} callback */ -Handle GitRepo::Init(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Init) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsBoolean()) { - return ThrowException(Exception::Error(String::New("Boolean is_bare is required."))); + return NanThrowError("Boolean is_bare is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } InitBaton* baton = new InitBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->pathReference = Persistent::New(args[0]); const char * from_path; String::Utf8Value path(args[0]->ToString()); from_path = strdup(*path); baton->path = from_path; - baton->is_bareReference = Persistent::New(args[1]); - unsigned from_is_bare; + unsigned from_is_bare; from_is_bare = (unsigned) args[1]->ToBoolean()->Value(); baton->is_bare = from_is_bare; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, InitWork, (uv_after_work_cb)InitAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + InitWorker *worker = new InitWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("path", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("is_bare", args[1]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::InitWork(uv_work_t *req) { - InitBaton *baton = static_cast(req->data); +void GitRepo::InitWorker::Execute() { int result = git_repository_init( &baton->out, baton->path, @@ -243,44 +238,38 @@ void GitRepo::InitWork(uv_work_t *req) { } } -void GitRepo::InitAfterWork(uv_work_t *req) { - HandleScope scope; - InitBaton *baton = static_cast(req->data); - +void GitRepo::InitWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitRepo::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->pathReference.Dispose(); - baton->is_bareReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->path); delete baton; } @@ -288,8 +277,8 @@ void GitRepo::InitAfterWork(uv_work_t *req) { /** * @return {String} result */ -Handle GitRepo::Path(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Path) { + NanScope(); const char * result = git_repository_path( @@ -297,15 +286,15 @@ Handle GitRepo::Path(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitRepo::Workdir(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Workdir) { + NanScope(); const char * result = git_repository_workdir( @@ -313,15 +302,15 @@ Handle GitRepo::Workdir(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Odb} out */ -Handle GitRepo::Odb(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Odb) { + NanScope(); git_odb * out = 0; @@ -331,9 +320,9 @@ Handle GitRepo::Odb(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -341,9 +330,9 @@ Handle GitRepo::Odb(const Arguments& args) { if (out != NULL) { to = GitOdb::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -351,28 +340,27 @@ Handle GitRepo::Odb(const Arguments& args) { /** * @param {Index} callback */ -Handle GitRepo::openIndex(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::openIndex) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } openIndexBaton* baton = new openIndexBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, openIndexWork, (uv_after_work_cb)openIndexAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + openIndexWorker *worker = new openIndexWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::openIndexWork(uv_work_t *req) { - openIndexBaton *baton = static_cast(req->data); +void GitRepo::openIndexWorker::Execute() { int result = git_repository_index( &baton->out, baton->repo @@ -383,43 +371,38 @@ void GitRepo::openIndexWork(uv_work_t *req) { } } -void GitRepo::openIndexAfterWork(uv_work_t *req) { - HandleScope scope; - openIndexBaton *baton = static_cast(req->data); - +void GitRepo::openIndexWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitIndex::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -429,35 +412,35 @@ void GitRepo::openIndexAfterWork(uv_work_t *req) { * @param {Oid} id * @param {Blob} callback */ -Handle GitRepo::GetBlob(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetBlob) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetBlobBaton* baton = new GetBlobBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetBlobWork, (uv_after_work_cb)GetBlobAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetBlobWorker *worker = new GetBlobWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetBlobWork(uv_work_t *req) { - GetBlobBaton *baton = static_cast(req->data); +void GitRepo::GetBlobWorker::Execute() { int result = git_blob_lookup( &baton->blob, baton->repo, @@ -469,44 +452,38 @@ void GitRepo::GetBlobWork(uv_work_t *req) { } } -void GitRepo::GetBlobAfterWork(uv_work_t *req) { - HandleScope scope; - GetBlobBaton *baton = static_cast(req->data); - +void GitRepo::GetBlobWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->blob != NULL) { to = GitBlob::New((void *)baton->blob); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -516,35 +493,35 @@ void GitRepo::GetBlobAfterWork(uv_work_t *req) { * @param {Oid} id * @param {Commit} callback */ -Handle GitRepo::GetCommit(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetCommit) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetCommitBaton* baton = new GetCommitBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetCommitWork, (uv_after_work_cb)GetCommitAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetCommitWorker *worker = new GetCommitWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetCommitWork(uv_work_t *req) { - GetCommitBaton *baton = static_cast(req->data); +void GitRepo::GetCommitWorker::Execute() { int result = git_commit_lookup( &baton->commit, baton->repo, @@ -556,44 +533,38 @@ void GitRepo::GetCommitWork(uv_work_t *req) { } } -void GitRepo::GetCommitAfterWork(uv_work_t *req) { - HandleScope scope; - GetCommitBaton *baton = static_cast(req->data); - +void GitRepo::GetCommitWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->commit != NULL) { to = GitCommit::New((void *)baton->commit); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -610,39 +581,36 @@ void GitRepo::GetCommitAfterWork(uv_work_t *req) { * @param {Array} parents * @param {Oid} callback */ -Handle GitRepo::CreateCommit(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateCommit) { + NanScope(); if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Signature author is required."))); + return NanThrowError("Signature author is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("Signature committer is required."))); + return NanThrowError("Signature committer is required."); } if (args.Length() == 4 || !args[4]->IsString()) { - return ThrowException(Exception::Error(String::New("String message is required."))); + return NanThrowError("String message is required."); } if (args.Length() == 5 || !args[5]->IsObject()) { - return ThrowException(Exception::Error(String::New("Tree tree is required."))); + return NanThrowError("Tree tree is required."); } if (args.Length() == 6 || !args[6]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number parent_count is required."))); + return NanThrowError("Number parent_count is required."); } if (args.Length() == 7 || !args[7]->IsObject()) { - return ThrowException(Exception::Error(String::New("Array parents is required."))); + return NanThrowError("Array parents is required."); } if (args.Length() == 8 || !args[8]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } CreateCommitBaton* baton = new CreateCommitBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->id = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->update_refReference = Persistent::New(args[0]); const char * from_update_ref; if (args[0]->IsString()) { String::Utf8Value update_ref(args[0]->ToString()); @@ -651,16 +619,13 @@ Handle GitRepo::CreateCommit(const Arguments& args) { from_update_ref = 0; } baton->update_ref = from_update_ref; - baton->authorReference = Persistent::New(args[1]); - const git_signature * from_author; + const git_signature * from_author; from_author = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); baton->author = from_author; - baton->committerReference = Persistent::New(args[2]); - const git_signature * from_committer; + const git_signature * from_committer; from_committer = ObjectWrap::Unwrap(args[2]->ToObject())->GetValue(); baton->committer = from_committer; - baton->message_encodingReference = Persistent::New(args[3]); - const char * from_message_encoding; + const char * from_message_encoding; if (args[3]->IsString()) { String::Utf8Value message_encoding(args[3]->ToString()); from_message_encoding = strdup(*message_encoding); @@ -668,37 +633,50 @@ Handle GitRepo::CreateCommit(const Arguments& args) { from_message_encoding = 0; } baton->message_encoding = from_message_encoding; - baton->messageReference = Persistent::New(args[4]); - const char * from_message; + const char * from_message; String::Utf8Value message(args[4]->ToString()); from_message = strdup(*message); baton->message = from_message; - baton->treeReference = Persistent::New(args[5]); - const git_tree * from_tree; + const git_tree * from_tree; from_tree = ObjectWrap::Unwrap(args[5]->ToObject())->GetValue(); baton->tree = from_tree; - baton->parent_countReference = Persistent::New(args[6]); - int from_parent_count; + int from_parent_count; from_parent_count = (int) args[6]->ToInt32()->Value(); baton->parent_count = from_parent_count; - baton->parentsReference = Persistent::New(args[7]); - const git_commit ** from_parents; + const git_commit ** from_parents; Array *tmp_parents = Array::Cast(*args[7]); from_parents = (const git_commit **)malloc(tmp_parents->Length() * sizeof(const git_commit *)); for (unsigned int i = 0; i < tmp_parents->Length(); i++) { - from_parents[i] = ObjectWrap::Unwrap(tmp_parents->Get(Number::New(static_cast(i)))->ToObject())->GetValue(); + from_parents[i] = ObjectWrap::Unwrap(tmp_parents->Get(NanNew(static_cast(i)))->ToObject())->GetValue(); } baton->parents = from_parents; - baton->callback = Persistent::New(Local::Cast(args[8])); - - uv_queue_work(uv_default_loop(), &baton->request, CreateCommitWork, (uv_after_work_cb)CreateCommitAfterWork); - - return Undefined(); -} - -void GitRepo::CreateCommitWork(uv_work_t *req) { - CreateCommitBaton *baton = static_cast(req->data); + + NanCallback *callback = new NanCallback(Local::Cast(args[8])); + CreateCommitWorker *worker = new CreateCommitWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("update_ref", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("author", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("committer", args[2]->ToObject()); + if (!args[3]->IsUndefined() && !args[3]->IsNull()) + worker->SaveToPersistent("message_encoding", args[3]->ToObject()); + if (!args[4]->IsUndefined() && !args[4]->IsNull()) + worker->SaveToPersistent("message", args[4]->ToObject()); + if (!args[5]->IsUndefined() && !args[5]->IsNull()) + worker->SaveToPersistent("tree", args[5]->ToObject()); + if (!args[6]->IsUndefined() && !args[6]->IsNull()) + worker->SaveToPersistent("parent_count", args[6]->ToObject()); + if (!args[7]->IsUndefined() && !args[7]->IsNull()) + worker->SaveToPersistent("parents", args[7]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); +} + +void GitRepo::CreateCommitWorker::Execute() { int result = git_commit_create( baton->id, baton->repo, @@ -717,35 +695,32 @@ void GitRepo::CreateCommitWork(uv_work_t *req) { } } -void GitRepo::CreateCommitAfterWork(uv_work_t *req) { - HandleScope scope; - CreateCommitBaton *baton = static_cast(req->data); - +void GitRepo::CreateCommitWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->id != NULL) { to = GitOid::New((void *)baton->id); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->id); } @@ -753,16 +728,6 @@ void GitRepo::CreateCommitAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->update_refReference.Dispose(); - baton->authorReference.Dispose(); - baton->committerReference.Dispose(); - baton->message_encodingReference.Dispose(); - baton->messageReference.Dispose(); - baton->treeReference.Dispose(); - baton->parent_countReference.Dispose(); - baton->parentsReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->update_ref); free((void *)baton->message_encoding); free((void *)baton->message); @@ -777,42 +742,43 @@ void GitRepo::CreateCommitAfterWork(uv_work_t *req) { * @param {Number} type * @param {Object} callback */ -Handle GitRepo::GetObject(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetObject) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number type is required."))); + return NanThrowError("Number type is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetObjectBaton* baton = new GetObjectBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->typeReference = Persistent::New(args[1]); - git_otype from_type; + git_otype from_type; from_type = (git_otype) args[1]->ToInt32()->Value(); baton->type = from_type; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, GetObjectWork, (uv_after_work_cb)GetObjectAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + GetObjectWorker *worker = new GetObjectWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("type", args[1]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetObjectWork(uv_work_t *req) { - GetObjectBaton *baton = static_cast(req->data); +void GitRepo::GetObjectWorker::Execute() { int result = git_object_lookup( &baton->object, baton->repo, @@ -825,45 +791,38 @@ void GitRepo::GetObjectWork(uv_work_t *req) { } } -void GitRepo::GetObjectAfterWork(uv_work_t *req) { - HandleScope scope; - GetObjectBaton *baton = static_cast(req->data); - +void GitRepo::GetObjectWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->object != NULL) { to = GitObject::New((void *)baton->object); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->idReference.Dispose(); - baton->typeReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -873,36 +832,36 @@ void GitRepo::GetObjectAfterWork(uv_work_t *req) { * @param {String} name * @param {Reference} callback */ -Handle GitRepo::GetReference(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetReference) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetReferenceBaton* baton = new GetReferenceBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->nameReference = Persistent::New(args[0]); const char * from_name; String::Utf8Value name(args[0]->ToString()); from_name = strdup(*name); baton->name = from_name; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetReferenceWork, (uv_after_work_cb)GetReferenceAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetReferenceWorker *worker = new GetReferenceWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("name", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetReferenceWork(uv_work_t *req) { - GetReferenceBaton *baton = static_cast(req->data); +void GitRepo::GetReferenceWorker::Execute() { int result = git_reference_lookup( &baton->out, baton->repo, @@ -914,44 +873,38 @@ void GitRepo::GetReferenceWork(uv_work_t *req) { } } -void GitRepo::GetReferenceAfterWork(uv_work_t *req) { - HandleScope scope; - GetReferenceBaton *baton = static_cast(req->data); - +void GitRepo::GetReferenceWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitReference::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->nameReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->name); delete baton; } @@ -962,16 +915,16 @@ void GitRepo::GetReferenceAfterWork(uv_work_t *req) { * @param {Number} force * @return {Reference} out */ -Handle GitRepo::CreateSymbolicReference(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateSymbolicReference) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String target is required."))); + return NanThrowError("String target is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } git_reference * out = 0; @@ -995,9 +948,9 @@ Handle GitRepo::CreateSymbolicReference(const Arguments& args) { free((void *)from_target); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -1005,9 +958,9 @@ Handle GitRepo::CreateSymbolicReference(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -1016,16 +969,16 @@ Handle GitRepo::CreateSymbolicReference(const Arguments& args) { * @param {Number} force * @return {Reference} out */ -Handle GitRepo::CreateReference(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateReference) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } git_reference * out = 0; @@ -1047,9 +1000,9 @@ Handle GitRepo::CreateReference(const Arguments& args) { free((void *)from_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -1057,9 +1010,9 @@ Handle GitRepo::CreateReference(const Arguments& args) { if (out != NULL) { to = GitReference::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -1069,44 +1022,45 @@ Handle GitRepo::CreateReference(const Arguments& args) { * @param {String} url * @param {Remote} callback */ -Handle GitRepo::AddRemote(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::AddRemote) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } AddRemoteBaton* baton = new AddRemoteBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->nameReference = Persistent::New(args[0]); const char * from_name; String::Utf8Value name(args[0]->ToString()); from_name = strdup(*name); baton->name = from_name; - baton->urlReference = Persistent::New(args[1]); - const char * from_url; + const char * from_url; String::Utf8Value url(args[1]->ToString()); from_url = strdup(*url); baton->url = from_url; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, AddRemoteWork, (uv_after_work_cb)AddRemoteAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + AddRemoteWorker *worker = new AddRemoteWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("name", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("url", args[1]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::AddRemoteWork(uv_work_t *req) { - AddRemoteBaton *baton = static_cast(req->data); +void GitRepo::AddRemoteWorker::Execute() { int result = git_remote_create( &baton->out, baton->repo, @@ -1119,45 +1073,38 @@ void GitRepo::AddRemoteWork(uv_work_t *req) { } } -void GitRepo::AddRemoteAfterWork(uv_work_t *req) { - HandleScope scope; - AddRemoteBaton *baton = static_cast(req->data); - +void GitRepo::AddRemoteWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitRemote::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->nameReference.Dispose(); - baton->urlReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->name); free((void *)baton->url); delete baton; @@ -1166,8 +1113,8 @@ void GitRepo::AddRemoteAfterWork(uv_work_t *req) { /** * @return {RevWalk} out */ -Handle GitRepo::CreateRevWalk(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateRevWalk) { + NanScope(); git_revwalk * out = 0; @@ -1177,9 +1124,9 @@ Handle GitRepo::CreateRevWalk(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -1187,19 +1134,19 @@ Handle GitRepo::CreateRevWalk(const Arguments& args) { if (out != NULL) { to = GitRevWalk::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {String} name * @return {Submodule} submodule */ -Handle GitRepo::GetSubmodule(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetSubmodule) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } git_submodule * submodule = 0; @@ -1215,9 +1162,9 @@ Handle GitRepo::GetSubmodule(const Arguments& args) { free((void *)from_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -1225,9 +1172,9 @@ Handle GitRepo::GetSubmodule(const Arguments& args) { if (submodule != NULL) { to = GitSubmodule::New((void *)submodule); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -1236,16 +1183,16 @@ Handle GitRepo::GetSubmodule(const Arguments& args) { * @param {Number} use_gitlink * @return {Submodule} submodule */ -Handle GitRepo::AddSubmodule(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::AddSubmodule) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number use_gitlink is required."))); + return NanThrowError("Number use_gitlink is required."); } git_submodule * submodule = 0; @@ -1269,9 +1216,9 @@ Handle GitRepo::AddSubmodule(const Arguments& args) { free((void *)from_path); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -1279,9 +1226,9 @@ Handle GitRepo::AddSubmodule(const Arguments& args) { if (submodule != NULL) { to = GitSubmodule::New((void *)submodule); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -1290,35 +1237,35 @@ Handle GitRepo::AddSubmodule(const Arguments& args) { * @param {Oid} id * @param {Tag} callback */ -Handle GitRepo::GetTag(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetTag) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetTagBaton* baton = new GetTagBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetTagWork, (uv_after_work_cb)GetTagAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetTagWorker *worker = new GetTagWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetTagWork(uv_work_t *req) { - GetTagBaton *baton = static_cast(req->data); +void GitRepo::GetTagWorker::Execute() { int result = git_tag_lookup( &baton->out, baton->repo, @@ -1330,44 +1277,38 @@ void GitRepo::GetTagWork(uv_work_t *req) { } } -void GitRepo::GetTagAfterWork(uv_work_t *req) { - HandleScope scope; - GetTagBaton *baton = static_cast(req->data); - +void GitRepo::GetTagWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitTag::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -1381,66 +1322,70 @@ void GitRepo::GetTagAfterWork(uv_work_t *req) { * @param {Number} force * @param {Oid} callback */ -Handle GitRepo::CreateTag(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateTag) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String tag_name is required."))); + return NanThrowError("String tag_name is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Object target is required."))); + return NanThrowError("Object target is required."); } if (args.Length() == 2 || !args[2]->IsObject()) { - return ThrowException(Exception::Error(String::New("Signature tagger is required."))); + return NanThrowError("Signature tagger is required."); } if (args.Length() == 3 || !args[3]->IsString()) { - return ThrowException(Exception::Error(String::New("String message is required."))); + return NanThrowError("String message is required."); } if (args.Length() == 4 || !args[4]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } if (args.Length() == 5 || !args[5]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } CreateTagBaton* baton = new CreateTagBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->oid = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->tag_nameReference = Persistent::New(args[0]); const char * from_tag_name; String::Utf8Value tag_name(args[0]->ToString()); from_tag_name = strdup(*tag_name); baton->tag_name = from_tag_name; - baton->targetReference = Persistent::New(args[1]); - const git_object * from_target; + const git_object * from_target; from_target = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); baton->target = from_target; - baton->taggerReference = Persistent::New(args[2]); - const git_signature * from_tagger; + const git_signature * from_tagger; from_tagger = ObjectWrap::Unwrap(args[2]->ToObject())->GetValue(); baton->tagger = from_tagger; - baton->messageReference = Persistent::New(args[3]); - const char * from_message; + const char * from_message; String::Utf8Value message(args[3]->ToString()); from_message = strdup(*message); baton->message = from_message; - baton->forceReference = Persistent::New(args[4]); - int from_force; + int from_force; from_force = (int) args[4]->ToInt32()->Value(); baton->force = from_force; - baton->callback = Persistent::New(Local::Cast(args[5])); - - uv_queue_work(uv_default_loop(), &baton->request, CreateTagWork, (uv_after_work_cb)CreateTagAfterWork); - - return Undefined(); -} - -void GitRepo::CreateTagWork(uv_work_t *req) { - CreateTagBaton *baton = static_cast(req->data); + + NanCallback *callback = new NanCallback(Local::Cast(args[5])); + CreateTagWorker *worker = new CreateTagWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("tag_name", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("target", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("tagger", args[2]->ToObject()); + if (!args[3]->IsUndefined() && !args[3]->IsNull()) + worker->SaveToPersistent("message", args[3]->ToObject()); + if (!args[4]->IsUndefined() && !args[4]->IsNull()) + worker->SaveToPersistent("force", args[4]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); +} + +void GitRepo::CreateTagWorker::Execute() { int result = git_tag_create( baton->oid, baton->repo, @@ -1456,35 +1401,32 @@ void GitRepo::CreateTagWork(uv_work_t *req) { } } -void GitRepo::CreateTagAfterWork(uv_work_t *req) { - HandleScope scope; - CreateTagBaton *baton = static_cast(req->data); - +void GitRepo::CreateTagWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->oid != NULL) { to = GitOid::New((void *)baton->oid); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->oid); } @@ -1492,13 +1434,6 @@ void GitRepo::CreateTagAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->tag_nameReference.Dispose(); - baton->targetReference.Dispose(); - baton->taggerReference.Dispose(); - baton->messageReference.Dispose(); - baton->forceReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->tag_name); free((void *)baton->message); delete baton; @@ -1512,51 +1447,53 @@ void GitRepo::CreateTagAfterWork(uv_work_t *req) { * @param {Number} force * @param {Oid} callback */ -Handle GitRepo::CreateLightweightTag(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateLightweightTag) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String tag_name is required."))); + return NanThrowError("String tag_name is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Object target is required."))); + return NanThrowError("Object target is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number force is required."))); + return NanThrowError("Number force is required."); } if (args.Length() == 3 || !args[3]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } CreateLightweightTagBaton* baton = new CreateLightweightTagBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->oid = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->tag_nameReference = Persistent::New(args[0]); const char * from_tag_name; String::Utf8Value tag_name(args[0]->ToString()); from_tag_name = strdup(*tag_name); baton->tag_name = from_tag_name; - baton->targetReference = Persistent::New(args[1]); - const git_object * from_target; + const git_object * from_target; from_target = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); baton->target = from_target; - baton->forceReference = Persistent::New(args[2]); - int from_force; + int from_force; from_force = (int) args[2]->ToInt32()->Value(); baton->force = from_force; - baton->callback = Persistent::New(Local::Cast(args[3])); - - uv_queue_work(uv_default_loop(), &baton->request, CreateLightweightTagWork, (uv_after_work_cb)CreateLightweightTagAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[3])); + CreateLightweightTagWorker *worker = new CreateLightweightTagWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("tag_name", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("target", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("force", args[2]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::CreateLightweightTagWork(uv_work_t *req) { - CreateLightweightTagBaton *baton = static_cast(req->data); +void GitRepo::CreateLightweightTagWorker::Execute() { int result = git_tag_create_lightweight( baton->oid, baton->repo, @@ -1570,35 +1507,32 @@ void GitRepo::CreateLightweightTagWork(uv_work_t *req) { } } -void GitRepo::CreateLightweightTagAfterWork(uv_work_t *req) { - HandleScope scope; - CreateLightweightTagBaton *baton = static_cast(req->data); - +void GitRepo::CreateLightweightTagWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->oid != NULL) { to = GitOid::New((void *)baton->oid); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->oid); } @@ -1606,11 +1540,6 @@ void GitRepo::CreateLightweightTagAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->tag_nameReference.Dispose(); - baton->targetReference.Dispose(); - baton->forceReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->tag_name); delete baton; } @@ -1621,35 +1550,35 @@ void GitRepo::CreateLightweightTagAfterWork(uv_work_t *req) { * @param {Oid} id * @param {Tree} callback */ -Handle GitRepo::GetTree(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetTree) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetTreeBaton* baton = new GetTreeBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetTreeWork, (uv_after_work_cb)GetTreeAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetTreeWorker *worker = new GetTreeWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetTreeWork(uv_work_t *req) { - GetTreeBaton *baton = static_cast(req->data); +void GitRepo::GetTreeWorker::Execute() { int result = git_tree_lookup( &baton->out, baton->repo, @@ -1661,44 +1590,38 @@ void GitRepo::GetTreeWork(uv_work_t *req) { } } -void GitRepo::GetTreeAfterWork(uv_work_t *req) { - HandleScope scope; - GetTreeBaton *baton = static_cast(req->data); - +void GitRepo::GetTreeWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitTree::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -1706,28 +1629,27 @@ void GitRepo::GetTreeAfterWork(uv_work_t *req) { /** */ -Handle GitRepo::ReloadSubmodules(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::ReloadSubmodules) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ReloadSubmodulesBaton* baton = new ReloadSubmodulesBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, ReloadSubmodulesWork, (uv_after_work_cb)ReloadSubmodulesAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + ReloadSubmodulesWorker *worker = new ReloadSubmodulesWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::ReloadSubmodulesWork(uv_work_t *req) { - ReloadSubmodulesBaton *baton = static_cast(req->data); +void GitRepo::ReloadSubmodulesWorker::Execute() { int result = git_submodule_reload_all( baton->repo ); @@ -1737,37 +1659,32 @@ void GitRepo::ReloadSubmodulesWork(uv_work_t *req) { } } -void GitRepo::ReloadSubmodulesAfterWork(uv_work_t *req) { - HandleScope scope; - ReloadSubmodulesBaton *baton = static_cast(req->data); - +void GitRepo::ReloadSubmodulesWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -1776,36 +1693,36 @@ void GitRepo::ReloadSubmodulesAfterWork(uv_work_t *req) { /** * @param {String} tag_name */ -Handle GitRepo::Delete(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Delete) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String tag_name is required."))); + return NanThrowError("String tag_name is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DeleteBaton* baton = new DeleteBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->tag_nameReference = Persistent::New(args[0]); const char * from_tag_name; String::Utf8Value tag_name(args[0]->ToString()); from_tag_name = strdup(*tag_name); baton->tag_name = from_tag_name; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, DeleteWork, (uv_after_work_cb)DeleteAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + DeleteWorker *worker = new DeleteWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("tag_name", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::DeleteWork(uv_work_t *req) { - DeleteBaton *baton = static_cast(req->data); +void GitRepo::DeleteWorker::Execute() { int result = git_tag_delete( baton->repo, baton->tag_name @@ -1816,38 +1733,32 @@ void GitRepo::DeleteWork(uv_work_t *req) { } } -void GitRepo::DeleteAfterWork(uv_work_t *req) { - HandleScope scope; - DeleteBaton *baton = static_cast(req->data); - +void GitRepo::DeleteWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->tag_nameReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->tag_name); delete baton; } @@ -1858,21 +1769,18 @@ void GitRepo::DeleteAfterWork(uv_work_t *req) { * @param {Number} list_flags * @param {Array} callback */ -Handle GitRepo::GetReferences(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetReferences) { + NanScope(); if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetReferencesBaton* baton = new GetReferencesBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->array = (git_strarray *)malloc(sizeof(git_strarray )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->list_flagsReference = Persistent::New(args[0]); unsigned int from_list_flags; if (args[0]->IsUint32()) { from_list_flags = (unsigned int) args[0]->ToUint32()->Value(); @@ -1880,15 +1788,18 @@ Handle GitRepo::GetReferences(const Arguments& args) { from_list_flags = 0; } baton->list_flags = from_list_flags; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetReferencesWork, (uv_after_work_cb)GetReferencesAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetReferencesWorker *worker = new GetReferencesWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("list_flags", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetReferencesWork(uv_work_t *req) { - GetReferencesBaton *baton = static_cast(req->data); +void GitRepo::GetReferencesWorker::Execute() { int result = git_reference_list( baton->array, baton->repo, @@ -1900,36 +1811,33 @@ void GitRepo::GetReferencesWork(uv_work_t *req) { } } -void GitRepo::GetReferencesAfterWork(uv_work_t *req) { - HandleScope scope; - GetReferencesBaton *baton = static_cast(req->data); - +void GitRepo::GetReferencesWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; - Local tmpArray = Array::New(baton->array->count); + Local tmpArray = NanNew(baton->array->count); for (unsigned int i = 0; i < baton->array->count; i++) { - tmpArray->Set(Number::New(i), String::New(baton->array->strings[i])); + tmpArray->Set(NanNew(i), NanNew(baton->array->strings[i])); } to = tmpArray; Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->array); } @@ -1937,9 +1845,6 @@ void GitRepo::GetReferencesAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->list_flagsReference.Dispose(); - baton->callback.Dispose(); git_strarray_free(baton->array); delete baton; @@ -1952,43 +1857,44 @@ void GitRepo::GetReferencesAfterWork(uv_work_t *req) { * @param {Number} len * @param {Oid} callback */ -Handle GitRepo::CreateBlobFromBuffer(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateBlobFromBuffer) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Buffer buffer is required."))); + return NanThrowError("Buffer buffer is required."); } if (args.Length() == 1 || !args[1]->IsNumber()) { - return ThrowException(Exception::Error(String::New("Number len is required."))); + return NanThrowError("Number len is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } CreateBlobFromBufferBaton* baton = new CreateBlobFromBufferBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->oid = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->bufferReference = Persistent::New(args[0]); const void * from_buffer; from_buffer = Buffer::Data(args[0]->ToObject()); baton->buffer = from_buffer; - baton->lenReference = Persistent::New(args[1]); - size_t from_len; + size_t from_len; from_len = (size_t) args[1]->ToNumber()->Value(); baton->len = from_len; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, CreateBlobFromBufferWork, (uv_after_work_cb)CreateBlobFromBufferAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + CreateBlobFromBufferWorker *worker = new CreateBlobFromBufferWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("buffer", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("len", args[1]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::CreateBlobFromBufferWork(uv_work_t *req) { - CreateBlobFromBufferBaton *baton = static_cast(req->data); +void GitRepo::CreateBlobFromBufferWorker::Execute() { int result = git_blob_create_frombuffer( baton->oid, baton->repo, @@ -2001,35 +1907,32 @@ void GitRepo::CreateBlobFromBufferWork(uv_work_t *req) { } } -void GitRepo::CreateBlobFromBufferAfterWork(uv_work_t *req) { - HandleScope scope; - CreateBlobFromBufferBaton *baton = static_cast(req->data); - +void GitRepo::CreateBlobFromBufferWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->oid != NULL) { to = GitOid::New((void *)baton->oid); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->oid); } @@ -2037,10 +1940,6 @@ void GitRepo::CreateBlobFromBufferAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->bufferReference.Dispose(); - baton->lenReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -2050,37 +1949,37 @@ void GitRepo::CreateBlobFromBufferAfterWork(uv_work_t *req) { * @param {String} path * @param {Oid} callback */ -Handle GitRepo::CreateBlobFromFile(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::CreateBlobFromFile) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } CreateBlobFromFileBaton* baton = new CreateBlobFromFileBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->id = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->pathReference = Persistent::New(args[0]); const char * from_path; String::Utf8Value path(args[0]->ToString()); from_path = strdup(*path); baton->path = from_path; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, CreateBlobFromFileWork, (uv_after_work_cb)CreateBlobFromFileAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + CreateBlobFromFileWorker *worker = new CreateBlobFromFileWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("path", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::CreateBlobFromFileWork(uv_work_t *req) { - CreateBlobFromFileBaton *baton = static_cast(req->data); +void GitRepo::CreateBlobFromFileWorker::Execute() { int result = git_blob_create_fromdisk( baton->id, baton->repo, @@ -2092,35 +1991,32 @@ void GitRepo::CreateBlobFromFileWork(uv_work_t *req) { } } -void GitRepo::CreateBlobFromFileAfterWork(uv_work_t *req) { - HandleScope scope; - CreateBlobFromFileBaton *baton = static_cast(req->data); - +void GitRepo::CreateBlobFromFileWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->id != NULL) { to = GitOid::New((void *)baton->id); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->id); } @@ -2128,9 +2024,6 @@ void GitRepo::CreateBlobFromFileAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->pathReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->path); delete baton; } @@ -2140,29 +2033,28 @@ void GitRepo::CreateBlobFromFileAfterWork(uv_work_t *req) { /** * @param {Array} callback */ -Handle GitRepo::GetRemotes(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetRemotes) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetRemotesBaton* baton = new GetRemotesBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->out = (git_strarray *)malloc(sizeof(git_strarray )); - baton->repoReference = Persistent::New(args.This()); baton->repo = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, GetRemotesWork, (uv_after_work_cb)GetRemotesAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + GetRemotesWorker *worker = new GetRemotesWorker(baton, callback); + worker->SaveToPersistent("repo", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::GetRemotesWork(uv_work_t *req) { - GetRemotesBaton *baton = static_cast(req->data); +void GitRepo::GetRemotesWorker::Execute() { int result = git_remote_list( baton->out, baton->repo @@ -2173,36 +2065,33 @@ void GitRepo::GetRemotesWork(uv_work_t *req) { } } -void GitRepo::GetRemotesAfterWork(uv_work_t *req) { - HandleScope scope; - GetRemotesBaton *baton = static_cast(req->data); - +void GitRepo::GetRemotesWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; - Local tmpArray = Array::New(baton->out->count); + Local tmpArray = NanNew(baton->out->count); for (unsigned int i = 0; i < baton->out->count; i++) { - tmpArray->Set(Number::New(i), String::New(baton->out->strings[i])); + tmpArray->Set(NanNew(i), NanNew(baton->out->strings[i])); } to = tmpArray; Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->out); } @@ -2210,8 +2099,6 @@ void GitRepo::GetRemotesAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->callback.Dispose(); git_strarray_free(baton->out); delete baton; @@ -2225,50 +2112,52 @@ void GitRepo::GetRemotesAfterWork(uv_work_t *req) { * @param {CloneOptions} options * @param {Repository} callback */ -Handle GitRepo::Clone(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::Clone) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String local_path is required."))); + return NanThrowError("String local_path is required."); } if (args.Length() == 3 || !args[3]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } CloneBaton* baton = new CloneBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->urlReference = Persistent::New(args[0]); const char * from_url; String::Utf8Value url(args[0]->ToString()); from_url = strdup(*url); baton->url = from_url; - baton->local_pathReference = Persistent::New(args[1]); - const char * from_local_path; + const char * from_local_path; String::Utf8Value local_path(args[1]->ToString()); from_local_path = strdup(*local_path); baton->local_path = from_local_path; - baton->optionsReference = Persistent::New(args[2]); - const git_clone_options * from_options; + const git_clone_options * from_options; if (args[2]->IsObject()) { from_options = ObjectWrap::Unwrap(args[2]->ToObject())->GetValue(); } else { from_options = 0; } baton->options = from_options; - baton->callback = Persistent::New(Local::Cast(args[3])); - - uv_queue_work(uv_default_loop(), &baton->request, CloneWork, (uv_after_work_cb)CloneAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[3])); + CloneWorker *worker = new CloneWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("url", args[0]->ToObject()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("local_path", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("options", args[2]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRepo::CloneWork(uv_work_t *req) { - CloneBaton *baton = static_cast(req->data); +void GitRepo::CloneWorker::Execute() { int result = git_clone( &baton->out, baton->url, @@ -2281,45 +2170,38 @@ void GitRepo::CloneWork(uv_work_t *req) { } } -void GitRepo::CloneAfterWork(uv_work_t *req) { - HandleScope scope; - CloneBaton *baton = static_cast(req->data); - +void GitRepo::CloneWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitRepo::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->urlReference.Dispose(); - baton->local_pathReference.Dispose(); - baton->optionsReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->url); free((void *)baton->local_path); delete baton; @@ -2329,10 +2211,10 @@ void GitRepo::CloneAfterWork(uv_work_t *req) { * @param {String} name * @return {Remote} out */ -Handle GitRepo::GetRemote(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRepo::GetRemote) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } git_remote * out = 0; @@ -2348,9 +2230,9 @@ Handle GitRepo::GetRemote(const Arguments& args) { free((void *)from_name); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -2358,9 +2240,9 @@ Handle GitRepo::GetRemote(const Arguments& args) { if (out != NULL) { to = GitRemote::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } Persistent GitRepo::constructor_template; diff --git a/src/revwalk.cc b/src/revwalk.cc index 20d7a940b..61430026f 100755 --- a/src/revwalk.cc +++ b/src/revwalk.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -25,12 +24,12 @@ GitRevWalk::~GitRevWalk() { } void GitRevWalk::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("RevWalk")); + tpl->SetClassName(NanNew("RevWalk")); NODE_SET_PROTOTYPE_METHOD(tpl, "reset", Reset); NODE_SET_PROTOTYPE_METHOD(tpl, "push", Push); @@ -45,27 +44,27 @@ void GitRevWalk::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "sorting", Sorting); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("RevWalk"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("RevWalk"), _constructor_template); } -Handle GitRevWalk::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_revwalk is required."))); + return NanThrowError("git_revwalk is required."); } - - GitRevWalk* object = new GitRevWalk((git_revwalk *) External::Unwrap(args[0])); + GitRevWalk* object = new GitRevWalk(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitRevWalk::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitRevWalk::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitRevWalk::constructor_template)->NewInstance(1, argv)); } git_revwalk *GitRevWalk::GetValue() { @@ -75,15 +74,15 @@ git_revwalk *GitRevWalk::GetValue() { /** */ -Handle GitRevWalk::Reset(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::Reset) { + NanScope(); git_revwalk_reset( ObjectWrap::Unwrap(args.This())->GetValue() ); - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" @@ -91,35 +90,35 @@ Handle GitRevWalk::Reset(const Arguments& args) { /** * @param {Oid} id */ -Handle GitRevWalk::Push(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::Push) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } PushBaton* baton = new PushBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->idReference = Persistent::New(args[0]); const git_oid * from_id; from_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->id = from_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, PushWork, (uv_after_work_cb)PushAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + PushWorker *worker = new PushWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("id", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::PushWork(uv_work_t *req) { - PushBaton *baton = static_cast(req->data); +void GitRevWalk::PushWorker::Execute() { int result = git_revwalk_push( baton->walk, baton->id @@ -130,38 +129,32 @@ void GitRevWalk::PushWork(uv_work_t *req) { } } -void GitRevWalk::PushAfterWork(uv_work_t *req) { - HandleScope scope; - PushBaton *baton = static_cast(req->data); - +void GitRevWalk::PushWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -170,36 +163,36 @@ void GitRevWalk::PushAfterWork(uv_work_t *req) { /** * @param {String} glob */ -Handle GitRevWalk::PushGlob(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::PushGlob) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String glob is required."))); + return NanThrowError("String glob is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } PushGlobBaton* baton = new PushGlobBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->globReference = Persistent::New(args[0]); const char * from_glob; String::Utf8Value glob(args[0]->ToString()); from_glob = strdup(*glob); baton->glob = from_glob; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, PushGlobWork, (uv_after_work_cb)PushGlobAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + PushGlobWorker *worker = new PushGlobWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("glob", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::PushGlobWork(uv_work_t *req) { - PushGlobBaton *baton = static_cast(req->data); +void GitRevWalk::PushGlobWorker::Execute() { int result = git_revwalk_push_glob( baton->walk, baton->glob @@ -210,38 +203,32 @@ void GitRevWalk::PushGlobWork(uv_work_t *req) { } } -void GitRevWalk::PushGlobAfterWork(uv_work_t *req) { - HandleScope scope; - PushGlobBaton *baton = static_cast(req->data); - +void GitRevWalk::PushGlobWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->globReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->glob); delete baton; } @@ -250,28 +237,27 @@ void GitRevWalk::PushGlobAfterWork(uv_work_t *req) { /** */ -Handle GitRevWalk::PushHead(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::PushHead) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } PushHeadBaton* baton = new PushHeadBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, PushHeadWork, (uv_after_work_cb)PushHeadAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + PushHeadWorker *worker = new PushHeadWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::PushHeadWork(uv_work_t *req) { - PushHeadBaton *baton = static_cast(req->data); +void GitRevWalk::PushHeadWorker::Execute() { int result = git_revwalk_push_head( baton->walk ); @@ -281,37 +267,32 @@ void GitRevWalk::PushHeadWork(uv_work_t *req) { } } -void GitRevWalk::PushHeadAfterWork(uv_work_t *req) { - HandleScope scope; - PushHeadBaton *baton = static_cast(req->data); - +void GitRevWalk::PushHeadWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -320,35 +301,35 @@ void GitRevWalk::PushHeadAfterWork(uv_work_t *req) { /** * @param {Oid} commit_id */ -Handle GitRevWalk::Hide(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::Hide) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid commit_id is required."))); + return NanThrowError("Oid commit_id is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } HideBaton* baton = new HideBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->commit_idReference = Persistent::New(args[0]); const git_oid * from_commit_id; from_commit_id = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->commit_id = from_commit_id; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, HideWork, (uv_after_work_cb)HideAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + HideWorker *worker = new HideWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("commit_id", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::HideWork(uv_work_t *req) { - HideBaton *baton = static_cast(req->data); +void GitRevWalk::HideWorker::Execute() { int result = git_revwalk_hide( baton->walk, baton->commit_id @@ -359,38 +340,32 @@ void GitRevWalk::HideWork(uv_work_t *req) { } } -void GitRevWalk::HideAfterWork(uv_work_t *req) { - HandleScope scope; - HideBaton *baton = static_cast(req->data); - +void GitRevWalk::HideWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->commit_idReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -399,36 +374,36 @@ void GitRevWalk::HideAfterWork(uv_work_t *req) { /** * @param {String} glob */ -Handle GitRevWalk::HideGlob(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::HideGlob) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String glob is required."))); + return NanThrowError("String glob is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } HideGlobBaton* baton = new HideGlobBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->globReference = Persistent::New(args[0]); const char * from_glob; String::Utf8Value glob(args[0]->ToString()); from_glob = strdup(*glob); baton->glob = from_glob; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, HideGlobWork, (uv_after_work_cb)HideGlobAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + HideGlobWorker *worker = new HideGlobWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("glob", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::HideGlobWork(uv_work_t *req) { - HideGlobBaton *baton = static_cast(req->data); +void GitRevWalk::HideGlobWorker::Execute() { int result = git_revwalk_hide_glob( baton->walk, baton->glob @@ -439,38 +414,32 @@ void GitRevWalk::HideGlobWork(uv_work_t *req) { } } -void GitRevWalk::HideGlobAfterWork(uv_work_t *req) { - HandleScope scope; - HideGlobBaton *baton = static_cast(req->data); - +void GitRevWalk::HideGlobWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->globReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->glob); delete baton; } @@ -479,28 +448,27 @@ void GitRevWalk::HideGlobAfterWork(uv_work_t *req) { /** */ -Handle GitRevWalk::HideHead(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::HideHead) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } HideHeadBaton* baton = new HideHeadBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, HideHeadWork, (uv_after_work_cb)HideHeadAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + HideHeadWorker *worker = new HideHeadWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::HideHeadWork(uv_work_t *req) { - HideHeadBaton *baton = static_cast(req->data); +void GitRevWalk::HideHeadWorker::Execute() { int result = git_revwalk_hide_head( baton->walk ); @@ -510,37 +478,32 @@ void GitRevWalk::HideHeadWork(uv_work_t *req) { } } -void GitRevWalk::HideHeadAfterWork(uv_work_t *req) { - HandleScope scope; - HideHeadBaton *baton = static_cast(req->data); - +void GitRevWalk::HideHeadWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -549,36 +512,36 @@ void GitRevWalk::HideHeadAfterWork(uv_work_t *req) { /** * @param {String} refname */ -Handle GitRevWalk::PushRef(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::PushRef) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String refname is required."))); + return NanThrowError("String refname is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } PushRefBaton* baton = new PushRefBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->refnameReference = Persistent::New(args[0]); const char * from_refname; String::Utf8Value refname(args[0]->ToString()); from_refname = strdup(*refname); baton->refname = from_refname; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, PushRefWork, (uv_after_work_cb)PushRefAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + PushRefWorker *worker = new PushRefWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("refname", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::PushRefWork(uv_work_t *req) { - PushRefBaton *baton = static_cast(req->data); +void GitRevWalk::PushRefWorker::Execute() { int result = git_revwalk_push_ref( baton->walk, baton->refname @@ -589,38 +552,32 @@ void GitRevWalk::PushRefWork(uv_work_t *req) { } } -void GitRevWalk::PushRefAfterWork(uv_work_t *req) { - HandleScope scope; - PushRefBaton *baton = static_cast(req->data); - +void GitRevWalk::PushRefWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->refnameReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->refname); delete baton; } @@ -630,36 +587,36 @@ void GitRevWalk::PushRefAfterWork(uv_work_t *req) { /** * @param {String} refname */ -Handle GitRevWalk::HideRef(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::HideRef) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String refname is required."))); + return NanThrowError("String refname is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } HideRefBaton* baton = new HideRefBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->refnameReference = Persistent::New(args[0]); const char * from_refname; String::Utf8Value refname(args[0]->ToString()); from_refname = strdup(*refname); baton->refname = from_refname; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, HideRefWork, (uv_after_work_cb)HideRefAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + HideRefWorker *worker = new HideRefWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("refname", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::HideRefWork(uv_work_t *req) { - HideRefBaton *baton = static_cast(req->data); +void GitRevWalk::HideRefWorker::Execute() { int result = git_revwalk_hide_ref( baton->walk, baton->refname @@ -670,38 +627,32 @@ void GitRevWalk::HideRefWork(uv_work_t *req) { } } -void GitRevWalk::HideRefAfterWork(uv_work_t *req) { - HandleScope scope; - HideRefBaton *baton = static_cast(req->data); - +void GitRevWalk::HideRefWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->refnameReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->refname); delete baton; } @@ -711,29 +662,28 @@ void GitRevWalk::HideRefAfterWork(uv_work_t *req) { /** * @param {Oid} callback */ -Handle GitRevWalk::Next(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::Next) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } NextBaton* baton = new NextBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->out = (git_oid *)malloc(sizeof(git_oid )); - baton->walkReference = Persistent::New(args.This()); baton->walk = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, NextWork, (uv_after_work_cb)NextAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + NextWorker *worker = new NextWorker(baton, callback); + worker->SaveToPersistent("walk", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitRevWalk::NextWork(uv_work_t *req) { - NextBaton *baton = static_cast(req->data); +void GitRevWalk::NextWorker::Execute() { int result = git_revwalk_next( baton->out, baton->walk @@ -744,35 +694,32 @@ void GitRevWalk::NextWork(uv_work_t *req) { } } -void GitRevWalk::NextAfterWork(uv_work_t *req) { - HandleScope scope; - NextBaton *baton = static_cast(req->data); - +void GitRevWalk::NextWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitOid::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->out); } @@ -780,18 +727,16 @@ void GitRevWalk::NextAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->walkReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** * @param {Number} sort_mode */ -Handle GitRevWalk::Sorting(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitRevWalk::Sorting) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number sort_mode is required."))); + return NanThrowError("Number sort_mode is required."); } unsigned int from_sort_mode; @@ -802,7 +747,7 @@ Handle GitRevWalk::Sorting(const Arguments& args) { , from_sort_mode ); - return Undefined(); + NanReturnUndefined(); } Persistent GitRevWalk::constructor_template; diff --git a/src/signature.cc b/src/signature.cc index d355896eb..26d181901 100755 --- a/src/signature.cc +++ b/src/signature.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -24,12 +23,12 @@ GitSignature::~GitSignature() { } void GitSignature::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Signature")); + tpl->SetClassName(NanNew("Signature")); NODE_SET_METHOD(tpl, "create", Create); NODE_SET_METHOD(tpl, "now", Now); @@ -38,27 +37,27 @@ void GitSignature::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "email", Email); NODE_SET_PROTOTYPE_METHOD(tpl, "time", Time); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Signature"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Signature"), _constructor_template); } -Handle GitSignature::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSignature::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_signature is required."))); + return NanThrowError("git_signature is required."); } - - GitSignature* object = new GitSignature((git_signature *) External::Unwrap(args[0])); + GitSignature* object = new GitSignature(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitSignature::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitSignature::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitSignature::constructor_template)->NewInstance(1, argv)); } git_signature *GitSignature::GetValue() { @@ -73,19 +72,19 @@ git_signature *GitSignature::GetValue() { * @param {Number} offset * @return {Signature} out */ -Handle GitSignature::Create(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSignature::Create) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String email is required."))); + return NanThrowError("String email is required."); } if (args.Length() == 2 || !args[2]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number time is required."))); + return NanThrowError("Number time is required."); } if (args.Length() == 3 || !args[3]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number offset is required."))); + return NanThrowError("Number offset is required."); } git_signature * out = 0; @@ -111,9 +110,9 @@ Handle GitSignature::Create(const Arguments& args) { free((void *)from_email); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -121,9 +120,9 @@ Handle GitSignature::Create(const Arguments& args) { if (out != NULL) { to = GitSignature::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -131,13 +130,13 @@ Handle GitSignature::Create(const Arguments& args) { * @param {String} email * @return {Signature} out */ -Handle GitSignature::Now(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSignature::Now) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String name is required."))); + return NanThrowError("String name is required."); } if (args.Length() == 1 || !args[1]->IsString()) { - return ThrowException(Exception::Error(String::New("String email is required."))); + return NanThrowError("String email is required."); } git_signature * out = 0; @@ -157,9 +156,9 @@ Handle GitSignature::Now(const Arguments& args) { free((void *)from_email); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -167,35 +166,35 @@ Handle GitSignature::Now(const Arguments& args) { if (out != NULL) { to = GitSignature::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } -Handle GitSignature::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSignature::Name) { + NanScope(); Handle to; const char * name = ObjectWrap::Unwrap(args.This())->GetValue()->name; - to = String::New(name); - return scope.Close(to); + to = NanNew(name); + NanReturnValue(to); } -Handle GitSignature::Email(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSignature::Email) { + NanScope(); Handle to; const char * email = ObjectWrap::Unwrap(args.This())->GetValue()->email; - to = String::New(email); - return scope.Close(to); + to = NanNew(email); + NanReturnValue(to); } -Handle GitSignature::Time(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSignature::Time) { + NanScope(); Handle to; git_time *when = @@ -207,9 +206,9 @@ Handle GitSignature::Time(const Arguments& args) { if (when != NULL) { to = GitTime::New((void *)when); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } Persistent GitSignature::constructor_template; diff --git a/src/submodule.cc b/src/submodule.cc index 2b355fc9c..22a9c5806 100644 --- a/src/submodule.cc +++ b/src/submodule.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -25,12 +24,12 @@ GitSubmodule::~GitSubmodule() { } void GitSubmodule::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Submodule")); + tpl->SetClassName(NanNew("Submodule")); NODE_SET_PROTOTYPE_METHOD(tpl, "addFinalize", AddFinalize); NODE_SET_PROTOTYPE_METHOD(tpl, "addToIndex", AddToIndex); @@ -48,27 +47,27 @@ void GitSubmodule::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "status", Status); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Submodule"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Submodule"), _constructor_template); } -Handle GitSubmodule::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_submodule is required."))); + return NanThrowError("git_submodule is required."); } - - GitSubmodule* object = new GitSubmodule((git_submodule *) External::Unwrap(args[0])); + GitSubmodule* object = new GitSubmodule(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitSubmodule::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitSubmodule::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitSubmodule::constructor_template)->NewInstance(1, argv)); } git_submodule *GitSubmodule::GetValue() { @@ -80,28 +79,27 @@ git_submodule *GitSubmodule::GetValue() { /** */ -Handle GitSubmodule::AddFinalize(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::AddFinalize) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } AddFinalizeBaton* baton = new AddFinalizeBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, AddFinalizeWork, (uv_after_work_cb)AddFinalizeAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + AddFinalizeWorker *worker = new AddFinalizeWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::AddFinalizeWork(uv_work_t *req) { - AddFinalizeBaton *baton = static_cast(req->data); +void GitSubmodule::AddFinalizeWorker::Execute() { int result = git_submodule_add_finalize( baton->submodule ); @@ -111,37 +109,32 @@ void GitSubmodule::AddFinalizeWork(uv_work_t *req) { } } -void GitSubmodule::AddFinalizeAfterWork(uv_work_t *req) { - HandleScope scope; - AddFinalizeBaton *baton = static_cast(req->data); - +void GitSubmodule::AddFinalizeWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -150,35 +143,35 @@ void GitSubmodule::AddFinalizeAfterWork(uv_work_t *req) { /** * @param {Number} write_index */ -Handle GitSubmodule::AddToIndex(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::AddToIndex) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number write_index is required."))); + return NanThrowError("Number write_index is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } AddToIndexBaton* baton = new AddToIndexBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->write_indexReference = Persistent::New(args[0]); int from_write_index; from_write_index = (int) args[0]->ToInt32()->Value(); baton->write_index = from_write_index; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, AddToIndexWork, (uv_after_work_cb)AddToIndexAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + AddToIndexWorker *worker = new AddToIndexWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("write_index", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::AddToIndexWork(uv_work_t *req) { - AddToIndexBaton *baton = static_cast(req->data); +void GitSubmodule::AddToIndexWorker::Execute() { int result = git_submodule_add_to_index( baton->submodule, baton->write_index @@ -189,38 +182,32 @@ void GitSubmodule::AddToIndexWork(uv_work_t *req) { } } -void GitSubmodule::AddToIndexAfterWork(uv_work_t *req) { - HandleScope scope; - AddToIndexBaton *baton = static_cast(req->data); - +void GitSubmodule::AddToIndexWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->write_indexReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -228,28 +215,27 @@ void GitSubmodule::AddToIndexAfterWork(uv_work_t *req) { /** */ -Handle GitSubmodule::Save(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Save) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } SaveBaton* baton = new SaveBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, SaveWork, (uv_after_work_cb)SaveAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + SaveWorker *worker = new SaveWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::SaveWork(uv_work_t *req) { - SaveBaton *baton = static_cast(req->data); +void GitSubmodule::SaveWorker::Execute() { int result = git_submodule_save( baton->submodule ); @@ -259,45 +245,40 @@ void GitSubmodule::SaveWork(uv_work_t *req) { } } -void GitSubmodule::SaveAfterWork(uv_work_t *req) { - HandleScope scope; - SaveBaton *baton = static_cast(req->data); - +void GitSubmodule::SaveWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** * @return {String} result */ -Handle GitSubmodule::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Name) { + NanScope(); const char * result = git_submodule_name( @@ -305,15 +286,15 @@ Handle GitSubmodule::Name(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitSubmodule::Path(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Path) { + NanScope(); const char * result = git_submodule_path( @@ -321,15 +302,15 @@ Handle GitSubmodule::Path(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitSubmodule::Url(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Url) { + NanScope(); const char * result = git_submodule_url( @@ -337,17 +318,17 @@ Handle GitSubmodule::Url(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @param {String} url */ -Handle GitSubmodule::SetUrl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::SetUrl) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String url is required."))); + return NanThrowError("String url is required."); } const char * from_url; @@ -361,20 +342,20 @@ Handle GitSubmodule::SetUrl(const Arguments& args) { free((void *)from_url); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** * @return {Oid} result */ -Handle GitSubmodule::IndexId(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::IndexId) { + NanScope(); const git_oid * result = git_submodule_index_id( @@ -388,16 +369,16 @@ Handle GitSubmodule::IndexId(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Oid} result */ -Handle GitSubmodule::HeadId(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::HeadId) { + NanScope(); const git_oid * result = git_submodule_head_id( @@ -411,9 +392,9 @@ Handle GitSubmodule::HeadId(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -421,35 +402,35 @@ Handle GitSubmodule::HeadId(const Arguments& args) { /** * @param {Number} overwrite */ -Handle GitSubmodule::Init(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Init) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number overwrite is required."))); + return NanThrowError("Number overwrite is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } InitBaton* baton = new InitBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->overwriteReference = Persistent::New(args[0]); int from_overwrite; from_overwrite = (int) args[0]->ToInt32()->Value(); baton->overwrite = from_overwrite; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, InitWork, (uv_after_work_cb)InitAfterWork); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + InitWorker *worker = new InitWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("overwrite", args[0]->ToObject()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::InitWork(uv_work_t *req) { - InitBaton *baton = static_cast(req->data); +void GitSubmodule::InitWorker::Execute() { int result = git_submodule_init( baton->submodule, baton->overwrite @@ -460,38 +441,32 @@ void GitSubmodule::InitWork(uv_work_t *req) { } } -void GitSubmodule::InitAfterWork(uv_work_t *req) { - HandleScope scope; - InitBaton *baton = static_cast(req->data); - +void GitSubmodule::InitWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->overwriteReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -499,28 +474,27 @@ void GitSubmodule::InitAfterWork(uv_work_t *req) { /** */ -Handle GitSubmodule::Sync(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Sync) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } SyncBaton* baton = new SyncBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, SyncWork, (uv_after_work_cb)SyncAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + SyncWorker *worker = new SyncWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::SyncWork(uv_work_t *req) { - SyncBaton *baton = static_cast(req->data); +void GitSubmodule::SyncWorker::Execute() { int result = git_submodule_sync( baton->submodule ); @@ -530,37 +504,32 @@ void GitSubmodule::SyncWork(uv_work_t *req) { } } -void GitSubmodule::SyncAfterWork(uv_work_t *req) { - HandleScope scope; - SyncBaton *baton = static_cast(req->data); - +void GitSubmodule::SyncWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -569,28 +538,27 @@ void GitSubmodule::SyncAfterWork(uv_work_t *req) { /** * @param {Repository} callback */ -Handle GitSubmodule::Open(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Open) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } OpenBaton* baton = new OpenBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, OpenWork, (uv_after_work_cb)OpenAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + OpenWorker *worker = new OpenWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::OpenWork(uv_work_t *req) { - OpenBaton *baton = static_cast(req->data); +void GitSubmodule::OpenWorker::Execute() { int result = git_submodule_open( &baton->repo, baton->submodule @@ -601,43 +569,38 @@ void GitSubmodule::OpenWork(uv_work_t *req) { } } -void GitSubmodule::OpenAfterWork(uv_work_t *req) { - HandleScope scope; - OpenBaton *baton = static_cast(req->data); - +void GitSubmodule::OpenWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->repo != NULL) { to = GitRepo::New((void *)baton->repo); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -645,28 +608,27 @@ void GitSubmodule::OpenAfterWork(uv_work_t *req) { /** */ -Handle GitSubmodule::Reload(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Reload) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } ReloadBaton* baton = new ReloadBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->submoduleReference = Persistent::New(args.This()); baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, ReloadWork, (uv_after_work_cb)ReloadAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + ReloadWorker *worker = new ReloadWorker(baton, callback); + worker->SaveToPersistent("submodule", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::ReloadWork(uv_work_t *req) { - ReloadBaton *baton = static_cast(req->data); +void GitSubmodule::ReloadWorker::Execute() { int result = git_submodule_reload( baton->submodule ); @@ -676,37 +638,32 @@ void GitSubmodule::ReloadWork(uv_work_t *req) { } } -void GitSubmodule::ReloadAfterWork(uv_work_t *req) { - HandleScope scope; - ReloadBaton *baton = static_cast(req->data); - +void GitSubmodule::ReloadWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->submoduleReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -715,35 +672,35 @@ void GitSubmodule::ReloadAfterWork(uv_work_t *req) { /** * @param {Number} status */ -Handle GitSubmodule::Status(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitSubmodule::Status) { + NanScope(); if (args.Length() == 0 || !args[0]->IsInt32()) { - return ThrowException(Exception::Error(String::New("Number status is required."))); + return NanThrowError("Number status is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } StatusBaton* baton = new StatusBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->statusReference = Persistent::New(args[0]); unsigned int * from_status; from_status = (unsigned int *) args[0]->ToInt32()->Value(); baton->status = from_status; - baton->submoduleReference = Persistent::New(args.This()); - baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[1])); + baton->submodule = ObjectWrap::Unwrap(args.This())->GetValue(); - uv_queue_work(uv_default_loop(), &baton->request, StatusWork, (uv_after_work_cb)StatusAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + StatusWorker *worker = new StatusWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("status", args[0]->ToObject()); + worker->SaveToPersistent("submodule", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitSubmodule::StatusWork(uv_work_t *req) { - StatusBaton *baton = static_cast(req->data); +void GitSubmodule::StatusWorker::Execute() { int result = git_submodule_status( baton->status, baton->submodule @@ -754,38 +711,32 @@ void GitSubmodule::StatusWork(uv_work_t *req) { } } -void GitSubmodule::StatusAfterWork(uv_work_t *req) { - HandleScope scope; - StatusBaton *baton = static_cast(req->data); - +void GitSubmodule::StatusWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - Handle result = Local::New(Undefined()); + Handle result = NanUndefined(); Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->statusReference.Dispose(); - baton->submoduleReference.Dispose(); - baton->callback.Dispose(); delete baton; } diff --git a/src/tag.cc b/src/tag.cc index 08b099d41..0717ab100 100644 --- a/src/tag.cc +++ b/src/tag.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -27,12 +26,12 @@ GitTag::~GitTag() { } void GitTag::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Tag")); + tpl->SetClassName(NanNew("Tag")); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); NODE_SET_PROTOTYPE_METHOD(tpl, "getTarget", GetTarget); @@ -44,27 +43,27 @@ void GitTag::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "peel", Peel); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Tag"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Tag"), _constructor_template); } -Handle GitTag::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_tag is required."))); + return NanThrowError("git_tag is required."); } - - GitTag* object = new GitTag((git_tag *) External::Unwrap(args[0])); + GitTag* object = new GitTag(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitTag::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitTag::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitTag::constructor_template)->NewInstance(1, argv)); } git_tag *GitTag::GetValue() { @@ -75,8 +74,8 @@ git_tag *GitTag::GetValue() { /** * @return {Oid} result */ -Handle GitTag::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::Oid) { + NanScope(); const git_oid * result = git_tag_id( @@ -90,9 +89,9 @@ Handle GitTag::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -100,28 +99,27 @@ Handle GitTag::Oid(const Arguments& args) { /** * @param {Object} callback */ -Handle GitTag::GetTarget(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::GetTarget) { + NanScope(); if (args.Length() == 0 || !args[0]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetTargetBaton* baton = new GetTargetBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->tagReference = Persistent::New(args.This()); baton->tag = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[0])); - uv_queue_work(uv_default_loop(), &baton->request, GetTargetWork, (uv_after_work_cb)GetTargetAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[0])); + GetTargetWorker *worker = new GetTargetWorker(baton, callback); + worker->SaveToPersistent("tag", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTag::GetTargetWork(uv_work_t *req) { - GetTargetBaton *baton = static_cast(req->data); +void GitTag::GetTargetWorker::Execute() { int result = git_tag_target( &baton->target_out, baton->tag @@ -132,51 +130,46 @@ void GitTag::GetTargetWork(uv_work_t *req) { } } -void GitTag::GetTargetAfterWork(uv_work_t *req) { - HandleScope scope; - GetTargetBaton *baton = static_cast(req->data); - +void GitTag::GetTargetWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->target_out != NULL) { to = GitObject::New((void *)baton->target_out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->tagReference.Dispose(); - baton->callback.Dispose(); delete baton; } /** * @return {Oid} result */ -Handle GitTag::TargetId(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::TargetId) { + NanScope(); const git_oid * result = git_tag_target_id( @@ -190,16 +183,16 @@ Handle GitTag::TargetId(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitTag::TargetType(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::TargetType) { + NanScope(); git_otype result = git_tag_target_type( @@ -207,15 +200,15 @@ Handle GitTag::TargetType(const Arguments& args) { ); Handle to; - to = Int32::New(result); - return scope.Close(to); + to = NanNew((int32_t)result); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitTag::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::Name) { + NanScope(); const char * result = git_tag_name( @@ -223,15 +216,15 @@ Handle GitTag::Name(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Signature} result */ -Handle GitTag::Tagger(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::Tagger) { + NanScope(); const git_signature * result = git_tag_tagger( @@ -245,16 +238,16 @@ Handle GitTag::Tagger(const Arguments& args) { if (result != NULL) { to = GitSignature::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {String} result */ -Handle GitTag::Message(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::Message) { + NanScope(); const char * result = git_tag_message( @@ -262,18 +255,18 @@ Handle GitTag::Message(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @param {Tag} tag * @return {Object} tag_target_out */ -Handle GitTag::Peel(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTag::Peel) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Tag tag is required."))); + return NanThrowError("Tag tag is required."); } git_object * tag_target_out = 0; @@ -286,9 +279,9 @@ Handle GitTag::Peel(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -296,9 +289,9 @@ Handle GitTag::Peel(const Arguments& args) { if (tag_target_out != NULL) { to = GitObject::New((void *)tag_target_out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } Persistent GitTag::constructor_template; diff --git a/src/threads.cc b/src/threads.cc index 020600206..5e36ef1cd 100755 --- a/src/threads.cc +++ b/src/threads.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -15,45 +14,45 @@ using namespace v8; using namespace node; void GitThreads::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Persistent object = Persistent::New(Object::New()); + Local object = NanNew(); - object->Set(String::NewSymbol("init"), FunctionTemplate::New(Init)->GetFunction()); - object->Set(String::NewSymbol("shutdown"), FunctionTemplate::New(Shutdown)->GetFunction()); + NODE_SET_METHOD(object, "init", Init); + NODE_SET_METHOD(object, "shutdown", Shutdown); - target->Set(String::NewSymbol("Threads"), object); + target->Set(NanNew("Threads"), object); } /** */ -Handle GitThreads::Init(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitThreads::Init) { + NanScope(); int result = git_threads_init( ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } /** */ -Handle GitThreads::Shutdown(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitThreads::Shutdown) { + NanScope(); git_threads_shutdown( ); - return Undefined(); + NanReturnUndefined(); } diff --git a/src/time.cc b/src/time.cc index b03a49c84..dd495947b 100644 --- a/src/time.cc +++ b/src/time.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -23,38 +22,38 @@ GitTime::~GitTime() { } void GitTime::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Time")); + tpl->SetClassName(NanNew("Time")); NODE_SET_PROTOTYPE_METHOD(tpl, "time", Time); NODE_SET_PROTOTYPE_METHOD(tpl, "offset", Offset); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Time"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Time"), _constructor_template); } -Handle GitTime::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTime::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_time is required."))); + return NanThrowError("git_time is required."); } - - GitTime* object = new GitTime((git_time *) External::Unwrap(args[0])); + GitTime* object = new GitTime(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitTime::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitTime::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitTime::constructor_template)->NewInstance(1, argv)); } git_time *GitTime::GetValue() { @@ -62,26 +61,26 @@ git_time *GitTime::GetValue() { } -Handle GitTime::Time(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTime::Time) { + NanScope(); Handle to; git_time_t time = ObjectWrap::Unwrap(args.This())->GetValue()->time; - to = Integer::New(time); - return scope.Close(to); + to = NanNew(time); + NanReturnValue(to); } -Handle GitTime::Offset(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTime::Offset) { + NanScope(); Handle to; int offset = ObjectWrap::Unwrap(args.This())->GetValue()->offset; - to = Int32::New(offset); - return scope.Close(to); + to = NanNew((int32_t)offset); + NanReturnValue(to); } Persistent GitTime::constructor_template; diff --git a/src/tree.cc b/src/tree.cc index 8a2661ce1..3686e35da 100755 --- a/src/tree.cc +++ b/src/tree.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -30,12 +29,12 @@ GitTree::~GitTree() { } void GitTree::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("Tree")); + tpl->SetClassName(NanNew("Tree")); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); NODE_SET_PROTOTYPE_METHOD(tpl, "size", Size); @@ -49,27 +48,27 @@ void GitTree::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "diffWorkDir", DiffWorkDir); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("Tree"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("Tree"), _constructor_template); } -Handle GitTree::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_tree is required."))); + return NanThrowError("git_tree is required."); } - - GitTree* object = new GitTree((git_tree *) External::Unwrap(args[0])); + GitTree* object = new GitTree(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitTree::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitTree::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitTree::constructor_template)->NewInstance(1, argv)); } git_tree *GitTree::GetValue() { @@ -80,8 +79,8 @@ git_tree *GitTree::GetValue() { /** * @return {Oid} result */ -Handle GitTree::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::Oid) { + NanScope(); const git_oid * result = git_tree_id( @@ -95,16 +94,16 @@ Handle GitTree::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitTree::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::Size) { + NanScope(); size_t result = git_tree_entrycount( @@ -112,18 +111,18 @@ Handle GitTree::Size(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** * @param {String} filename * @return {TreeEntry} result */ -Handle GitTree::EntryByName(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::EntryByName) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String filename is required."))); + return NanThrowError("String filename is required."); } const char * from_filename; @@ -143,19 +142,19 @@ Handle GitTree::EntryByName(const Arguments& args) { if (result != NULL) { to = GitTreeEntry::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Number} idx * @return {TreeEntry} result */ -Handle GitTree::EntryByIndex(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::EntryByIndex) { + NanScope(); if (args.Length() == 0 || !args[0]->IsUint32()) { - return ThrowException(Exception::Error(String::New("Number idx is required."))); + return NanThrowError("Number idx is required."); } size_t from_idx; @@ -173,19 +172,19 @@ Handle GitTree::EntryByIndex(const Arguments& args) { if (result != NULL) { to = GitTreeEntry::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {Oid} oid * @return {TreeEntry} result */ -Handle GitTree::EntryByOid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::EntryByOid) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid oid is required."))); + return NanThrowError("Oid oid is required."); } const git_oid * from_oid; @@ -203,9 +202,9 @@ Handle GitTree::EntryByOid(const Arguments& args) { if (result != NULL) { to = GitTreeEntry::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -214,36 +213,36 @@ Handle GitTree::EntryByOid(const Arguments& args) { * @param {String} path * @param {TreeEntry} callback */ -Handle GitTree::GetEntry(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::GetEntry) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String path is required."))); + return NanThrowError("String path is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetEntryBaton* baton = new GetEntryBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->rootReference = Persistent::New(args.This()); baton->root = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->pathReference = Persistent::New(args[0]); const char * from_path; String::Utf8Value path(args[0]->ToString()); from_path = strdup(*path); baton->path = from_path; - baton->callback = Persistent::New(Local::Cast(args[1])); - - uv_queue_work(uv_default_loop(), &baton->request, GetEntryWork, (uv_after_work_cb)GetEntryAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetEntryWorker *worker = new GetEntryWorker(baton, callback); + worker->SaveToPersistent("root", args.This()); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("path", args[0]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTree::GetEntryWork(uv_work_t *req) { - GetEntryBaton *baton = static_cast(req->data); +void GitTree::GetEntryWorker::Execute() { int result = git_tree_entry_bypath( &baton->out, baton->root, @@ -255,44 +254,38 @@ void GitTree::GetEntryWork(uv_work_t *req) { } } -void GitTree::GetEntryAfterWork(uv_work_t *req) { - HandleScope scope; - GetEntryBaton *baton = static_cast(req->data); - +void GitTree::GetEntryWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->out != NULL) { to = GitTreeEntry::New((void *)baton->out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->rootReference.Dispose(); - baton->pathReference.Dispose(); - baton->callback.Dispose(); free((void *)baton->path); delete baton; } @@ -300,8 +293,8 @@ void GitTree::GetEntryAfterWork(uv_work_t *req) { /** * @return {TreeBuilder} out */ -Handle GitTree::Builder(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::Builder) { + NanScope(); git_treebuilder * out = 0; @@ -311,9 +304,9 @@ Handle GitTree::Builder(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -321,9 +314,9 @@ Handle GitTree::Builder(const Arguments& args) { if (out != NULL) { to = GitTreeBuilder::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -334,50 +327,52 @@ Handle GitTree::Builder(const Arguments& args) { * @param {DiffOptions} opts * @param {DiffList} callback */ -Handle GitTree::DiffTree(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::DiffTree) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Tree new_tree is required."))); + return NanThrowError("Tree new_tree is required."); } if (args.Length() == 3 || !args[3]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DiffTreeBaton* baton = new DiffTreeBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->old_treeReference = Persistent::New(args.This()); - baton->old_tree = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->new_treeReference = Persistent::New(args[1]); + baton->old_tree = ObjectWrap::Unwrap(args.This())->GetValue(); git_tree * from_new_tree; from_new_tree = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); baton->new_tree = from_new_tree; - baton->optsReference = Persistent::New(args[2]); - const git_diff_options * from_opts; + const git_diff_options * from_opts; if (args[2]->IsObject()) { from_opts = ObjectWrap::Unwrap(args[2]->ToObject())->GetValue(); } else { from_opts = 0; } baton->opts = from_opts; - baton->callback = Persistent::New(Local::Cast(args[3])); - - uv_queue_work(uv_default_loop(), &baton->request, DiffTreeWork, (uv_after_work_cb)DiffTreeAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[3])); + DiffTreeWorker *worker = new DiffTreeWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + worker->SaveToPersistent("old_tree", args.This()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("new_tree", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("opts", args[2]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTree::DiffTreeWork(uv_work_t *req) { - DiffTreeBaton *baton = static_cast(req->data); +void GitTree::DiffTreeWorker::Execute() { int result = git_diff_tree_to_tree( &baton->diff, baton->repo, @@ -391,46 +386,38 @@ void GitTree::DiffTreeWork(uv_work_t *req) { } } -void GitTree::DiffTreeAfterWork(uv_work_t *req) { - HandleScope scope; - DiffTreeBaton *baton = static_cast(req->data); - +void GitTree::DiffTreeWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->diff != NULL) { to = GitDiffList::New((void *)baton->diff); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->old_treeReference.Dispose(); - baton->new_treeReference.Dispose(); - baton->optsReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -442,27 +429,23 @@ void GitTree::DiffTreeAfterWork(uv_work_t *req) { * @param {DiffOptions} opts * @param {DiffList} callback */ -Handle GitTree::DiffIndex(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::DiffIndex) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 3 || !args[3]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DiffIndexBaton* baton = new DiffIndexBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->old_treeReference = Persistent::New(args.This()); - baton->old_tree = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->indexReference = Persistent::New(args[1]); + baton->old_tree = ObjectWrap::Unwrap(args.This())->GetValue(); git_index * from_index; if (args[1]->IsObject()) { from_index = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); @@ -470,23 +453,29 @@ Handle GitTree::DiffIndex(const Arguments& args) { from_index = 0; } baton->index = from_index; - baton->optsReference = Persistent::New(args[2]); - const git_diff_options * from_opts; + const git_diff_options * from_opts; if (args[2]->IsObject()) { from_opts = ObjectWrap::Unwrap(args[2]->ToObject())->GetValue(); } else { from_opts = 0; } baton->opts = from_opts; - baton->callback = Persistent::New(Local::Cast(args[3])); - - uv_queue_work(uv_default_loop(), &baton->request, DiffIndexWork, (uv_after_work_cb)DiffIndexAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[3])); + DiffIndexWorker *worker = new DiffIndexWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + worker->SaveToPersistent("old_tree", args.This()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("index", args[1]->ToObject()); + if (!args[2]->IsUndefined() && !args[2]->IsNull()) + worker->SaveToPersistent("opts", args[2]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTree::DiffIndexWork(uv_work_t *req) { - DiffIndexBaton *baton = static_cast(req->data); +void GitTree::DiffIndexWorker::Execute() { int result = git_diff_tree_to_index( &baton->diff, baton->repo, @@ -500,46 +489,38 @@ void GitTree::DiffIndexWork(uv_work_t *req) { } } -void GitTree::DiffIndexAfterWork(uv_work_t *req) { - HandleScope scope; - DiffIndexBaton *baton = static_cast(req->data); - +void GitTree::DiffIndexWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->diff != NULL) { to = GitDiffList::New((void *)baton->diff); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->old_treeReference.Dispose(); - baton->indexReference.Dispose(); - baton->optsReference.Dispose(); - baton->callback.Dispose(); delete baton; } @@ -550,27 +531,23 @@ void GitTree::DiffIndexAfterWork(uv_work_t *req) { * @param {DiffOptions} opts * @param {DiffList} callback */ -Handle GitTree::DiffWorkDir(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTree::DiffWorkDir) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 2 || !args[2]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } DiffWorkDirBaton* baton = new DiffWorkDirBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->old_treeReference = Persistent::New(args.This()); - baton->old_tree = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->optsReference = Persistent::New(args[1]); + baton->old_tree = ObjectWrap::Unwrap(args.This())->GetValue(); const git_diff_options * from_opts; if (args[1]->IsObject()) { from_opts = ObjectWrap::Unwrap(args[1]->ToObject())->GetValue(); @@ -578,15 +555,20 @@ Handle GitTree::DiffWorkDir(const Arguments& args) { from_opts = 0; } baton->opts = from_opts; - baton->callback = Persistent::New(Local::Cast(args[2])); - - uv_queue_work(uv_default_loop(), &baton->request, DiffWorkDirWork, (uv_after_work_cb)DiffWorkDirAfterWork); - - return Undefined(); + + NanCallback *callback = new NanCallback(Local::Cast(args[2])); + DiffWorkDirWorker *worker = new DiffWorkDirWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + worker->SaveToPersistent("old_tree", args.This()); + if (!args[1]->IsUndefined() && !args[1]->IsNull()) + worker->SaveToPersistent("opts", args[1]->ToObject()); + + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTree::DiffWorkDirWork(uv_work_t *req) { - DiffWorkDirBaton *baton = static_cast(req->data); +void GitTree::DiffWorkDirWorker::Execute() { int result = git_diff_tree_to_workdir( &baton->diff, baton->repo, @@ -599,45 +581,38 @@ void GitTree::DiffWorkDirWork(uv_work_t *req) { } } -void GitTree::DiffWorkDirAfterWork(uv_work_t *req) { - HandleScope scope; - DiffWorkDirBaton *baton = static_cast(req->data); - +void GitTree::DiffWorkDirWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->diff != NULL) { to = GitDiffList::New((void *)baton->diff); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->old_treeReference.Dispose(); - baton->optsReference.Dispose(); - baton->callback.Dispose(); delete baton; } diff --git a/src/tree_builder.cc b/src/tree_builder.cc index 3a6b6585f..fd08dda9d 100644 --- a/src/tree_builder.cc +++ b/src/tree_builder.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -30,12 +29,12 @@ GitTreeBuilder::~GitTreeBuilder() { } void GitTreeBuilder::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("TreeBuilder")); + tpl->SetClassName(NanNew("TreeBuilder")); NODE_SET_METHOD(tpl, "create", Create); NODE_SET_PROTOTYPE_METHOD(tpl, "clear", Clear); @@ -46,27 +45,27 @@ void GitTreeBuilder::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "write", Write); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("TreeBuilder"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("TreeBuilder"), _constructor_template); } -Handle GitTreeBuilder::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_treebuilder is required."))); + return NanThrowError("git_treebuilder is required."); } - - GitTreeBuilder* object = new GitTreeBuilder((git_treebuilder *) External::Unwrap(args[0])); + GitTreeBuilder* object = new GitTreeBuilder(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitTreeBuilder::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitTreeBuilder::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitTreeBuilder::constructor_template)->NewInstance(1, argv)); } git_treebuilder *GitTreeBuilder::GetValue() { @@ -78,8 +77,8 @@ git_treebuilder *GitTreeBuilder::GetValue() { * @param {Tree} source * @return {TreeBuilder} out */ -Handle GitTreeBuilder::Create(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::Create) { + NanScope(); git_treebuilder * out = 0; const git_tree * from_source; @@ -95,9 +94,9 @@ Handle GitTreeBuilder::Create(const Arguments& args) { ); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -105,18 +104,18 @@ Handle GitTreeBuilder::Create(const Arguments& args) { if (out != NULL) { to = GitTreeBuilder::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {TreeBuilder} bld */ -Handle GitTreeBuilder::Clear(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::Clear) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("TreeBuilder bld is required."))); + return NanThrowError("TreeBuilder bld is required."); } git_treebuilder * from_bld; @@ -126,14 +125,14 @@ Handle GitTreeBuilder::Clear(const Arguments& args) { from_bld ); - return Undefined(); + NanReturnUndefined(); } /** * @return {Number} result */ -Handle GitTreeBuilder::Size(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::Size) { + NanScope(); unsigned int result = git_treebuilder_entrycount( @@ -141,18 +140,18 @@ Handle GitTreeBuilder::Size(const Arguments& args) { ); Handle to; - to = Uint32::New(result); - return scope.Close(to); + to = NanNew((uint32_t)result); + NanReturnValue(to); } /** * @param {String} filename * @return {TreeEntry} result */ -Handle GitTreeBuilder::Get(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::Get) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String filename is required."))); + return NanThrowError("String filename is required."); } const char * from_filename; @@ -172,9 +171,9 @@ Handle GitTreeBuilder::Get(const Arguments& args) { if (result != NULL) { to = GitTreeEntry::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** @@ -183,16 +182,16 @@ Handle GitTreeBuilder::Get(const Arguments& args) { * @param {Number} filemode * @return {TreeEntry} out */ -Handle GitTreeBuilder::Insert(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::Insert) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String filename is required."))); + return NanThrowError("String filename is required."); } if (args.Length() == 1 || !args[1]->IsObject()) { - return ThrowException(Exception::Error(String::New("Oid id is required."))); + return NanThrowError("Oid id is required."); } if (args.Length() == 2 || !args[2]->IsNumber()) { - return ThrowException(Exception::Error(String::New("Number filemode is required."))); + return NanThrowError("Number filemode is required."); } const git_tree_entry * out = 0; @@ -214,9 +213,9 @@ Handle GitTreeBuilder::Insert(const Arguments& args) { free((void *)from_filename); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } @@ -227,18 +226,18 @@ Handle GitTreeBuilder::Insert(const Arguments& args) { if (out != NULL) { to = GitTreeEntry::New((void *)out); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @param {String} filename */ -Handle GitTreeBuilder::GitTreebuilderRemove(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::GitTreebuilderRemove) { + NanScope(); if (args.Length() == 0 || !args[0]->IsString()) { - return ThrowException(Exception::Error(String::New("String filename is required."))); + return NanThrowError("String filename is required."); } const char * from_filename; @@ -252,13 +251,13 @@ Handle GitTreeBuilder::GitTreebuilderRemove(const Arguments& args) { free((void *)from_filename); if (result != GIT_OK) { if (giterr_last()) { - return ThrowException(Exception::Error(String::New(giterr_last()->message))); + return NanThrowError(giterr_last()->message); } else { - return ThrowException(Exception::Error(String::New("Unkown Error"))); + return NanThrowError("Unknown Error"); } } - return Undefined(); + NanReturnUndefined(); } #include "../include/functions/copy.h" @@ -267,36 +266,36 @@ Handle GitTreeBuilder::GitTreebuilderRemove(const Arguments& args) { * @param {Repository} repo * @param {Oid} callback */ -Handle GitTreeBuilder::Write(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeBuilder::Write) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } WriteBaton* baton = new WriteBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; baton->id = (git_oid *)malloc(sizeof(git_oid )); - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->bldReference = Persistent::New(args.This()); - baton->bld = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[1])); + baton->bld = ObjectWrap::Unwrap(args.This())->GetValue(); - uv_queue_work(uv_default_loop(), &baton->request, WriteWork, (uv_after_work_cb)WriteAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + WriteWorker *worker = new WriteWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + worker->SaveToPersistent("bld", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTreeBuilder::WriteWork(uv_work_t *req) { - WriteBaton *baton = static_cast(req->data); +void GitTreeBuilder::WriteWorker::Execute() { int result = git_treebuilder_write( baton->id, baton->repo, @@ -308,35 +307,32 @@ void GitTreeBuilder::WriteWork(uv_work_t *req) { } } -void GitTreeBuilder::WriteAfterWork(uv_work_t *req) { - HandleScope scope; - WriteBaton *baton = static_cast(req->data); - +void GitTreeBuilder::WriteWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->id != NULL) { to = GitOid::New((void *)baton->id); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } free(baton->id); } @@ -344,9 +340,6 @@ void GitTreeBuilder::WriteAfterWork(uv_work_t *req) { if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->bldReference.Dispose(); - baton->callback.Dispose(); delete baton; } diff --git a/src/tree_entry.cc b/src/tree_entry.cc index 2d761e611..10fe341fc 100755 --- a/src/tree_entry.cc +++ b/src/tree_entry.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include "git2.h" @@ -26,12 +25,12 @@ GitTreeEntry::~GitTreeEntry() { } void GitTreeEntry::Initialize(Handle target) { - HandleScope scope; + NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(String::NewSymbol("TreeEntry")); + tpl->SetClassName(NanNew("TreeEntry")); NODE_SET_PROTOTYPE_METHOD(tpl, "name", Name); NODE_SET_PROTOTYPE_METHOD(tpl, "oid", Oid); @@ -40,27 +39,27 @@ void GitTreeEntry::Initialize(Handle target) { NODE_SET_PROTOTYPE_METHOD(tpl, "getObject", GetObject); - constructor_template = Persistent::New(tpl->GetFunction()); - target->Set(String::NewSymbol("TreeEntry"), constructor_template); + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("TreeEntry"), _constructor_template); } -Handle GitTreeEntry::New(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeEntry::New) { + NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return ThrowException(Exception::Error(String::New("git_tree_entry is required."))); + return NanThrowError("git_tree_entry is required."); } - - GitTreeEntry* object = new GitTreeEntry((git_tree_entry *) External::Unwrap(args[0])); + GitTreeEntry* object = new GitTreeEntry(static_cast(Handle::Cast(args[0])->Value())); object->Wrap(args.This()); - return scope.Close(args.This()); + NanReturnValue(args.This()); } Handle GitTreeEntry::New(void *raw) { - HandleScope scope; - Handle argv[1] = { External::New((void *)raw) }; - return scope.Close(GitTreeEntry::constructor_template->NewInstance(1, argv)); + NanEscapableScope(); + Handle argv[1] = { NanNew((void *)raw) }; + return NanEscapeScope(NanNew(GitTreeEntry::constructor_template)->NewInstance(1, argv)); } git_tree_entry *GitTreeEntry::GetValue() { @@ -71,8 +70,8 @@ git_tree_entry *GitTreeEntry::GetValue() { /** * @return {String} result */ -Handle GitTreeEntry::Name(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeEntry::Name) { + NanScope(); const char * result = git_tree_entry_name( @@ -80,15 +79,15 @@ Handle GitTreeEntry::Name(const Arguments& args) { ); Handle to; - to = String::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Oid} result */ -Handle GitTreeEntry::Oid(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeEntry::Oid) { + NanScope(); const git_oid * result = git_tree_entry_id( @@ -102,16 +101,16 @@ Handle GitTreeEntry::Oid(const Arguments& args) { if (result != NULL) { to = GitOid::New((void *)result); } else { - to = Null(); + to = NanNull(); } - return scope.Close(to); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitTreeEntry::Type(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeEntry::Type) { + NanScope(); git_otype result = git_tree_entry_type( @@ -119,15 +118,15 @@ Handle GitTreeEntry::Type(const Arguments& args) { ); Handle to; - to = Number::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } /** * @return {Number} result */ -Handle GitTreeEntry::filemode(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeEntry::filemode) { + NanScope(); git_filemode_t result = git_tree_entry_filemode( @@ -135,8 +134,8 @@ Handle GitTreeEntry::filemode(const Arguments& args) { ); Handle to; - to = Number::New(result); - return scope.Close(to); + to = NanNew(result); + NanReturnValue(to); } #include "../include/functions/copy.h" @@ -145,35 +144,35 @@ Handle GitTreeEntry::filemode(const Arguments& args) { * @param {Repository} repo * @param {Object} callback */ -Handle GitTreeEntry::GetObject(const Arguments& args) { - HandleScope scope; +NAN_METHOD(GitTreeEntry::GetObject) { + NanScope(); if (args.Length() == 0 || !args[0]->IsObject()) { - return ThrowException(Exception::Error(String::New("Repository repo is required."))); + return NanThrowError("Repository repo is required."); } if (args.Length() == 1 || !args[1]->IsFunction()) { - return ThrowException(Exception::Error(String::New("Callback is required and must be a Function."))); + return NanThrowError("Callback is required and must be a Function."); } GetObjectBaton* baton = new GetObjectBaton; baton->error_code = GIT_OK; baton->error = NULL; - baton->request.data = baton; - baton->repoReference = Persistent::New(args[0]); git_repository * from_repo; from_repo = ObjectWrap::Unwrap(args[0]->ToObject())->GetValue(); baton->repo = from_repo; - baton->entryReference = Persistent::New(args.This()); - baton->entry = ObjectWrap::Unwrap(args.This())->GetValue(); - baton->callback = Persistent::New(Local::Cast(args[1])); + baton->entry = ObjectWrap::Unwrap(args.This())->GetValue(); - uv_queue_work(uv_default_loop(), &baton->request, GetObjectWork, (uv_after_work_cb)GetObjectAfterWork); + NanCallback *callback = new NanCallback(Local::Cast(args[1])); + GetObjectWorker *worker = new GetObjectWorker(baton, callback); + if (!args[0]->IsUndefined() && !args[0]->IsNull()) + worker->SaveToPersistent("repo", args[0]->ToObject()); + worker->SaveToPersistent("entry", args.This()); - return Undefined(); + NanAsyncQueueWorker(worker); + NanReturnUndefined(); } -void GitTreeEntry::GetObjectWork(uv_work_t *req) { - GetObjectBaton *baton = static_cast(req->data); +void GitTreeEntry::GetObjectWorker::Execute() { int result = git_tree_entry_to_object( &baton->object_out, baton->repo, @@ -185,44 +184,38 @@ void GitTreeEntry::GetObjectWork(uv_work_t *req) { } } -void GitTreeEntry::GetObjectAfterWork(uv_work_t *req) { - HandleScope scope; - GetObjectBaton *baton = static_cast(req->data); - +void GitTreeEntry::GetObjectWorker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { Handle to; if (baton->object_out != NULL) { to = GitObject::New((void *)baton->object_out); } else { - to = Null(); + to = NanNull(); } Handle result = to; Handle argv[2] = { - Local::New(Null()), + NanNull(), result }; - baton->callback->Call(Context::GetCurrent()->Global(), 2, argv); + callback->Call(2, argv); } else { if (baton->error) { Handle argv[1] = { - Exception::Error(String::New(baton->error->message)) + NanError(baton->error->message) }; - baton->callback->Call(Context::GetCurrent()->Global(), 1, argv); + callback->Call(1, argv); if (baton->error->message) free((void *)baton->error->message); free((void *)baton->error); } else { - baton->callback->Call(Context::GetCurrent()->Global(), 0, NULL); + callback->Call(0, NULL); } } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - baton->repoReference.Dispose(); - baton->entryReference.Dispose(); - baton->callback.Dispose(); delete baton; } diff --git a/src/wrapper.cc b/src/wrapper.cc index f2d2463be..ac719d464 100644 --- a/src/wrapper.cc +++ b/src/wrapper.cc @@ -1,8 +1,7 @@ /** * This code is auto-generated; unless you know what you're doing, do not modify! **/ -#include -#include +#include #include #include @@ -19,22 +18,22 @@ Wrapper::Wrapper(void *raw) { void Wrapper::Initialize(Handle target) { NanScope(); - Local tpl = FunctionTemplate::New(New); + Local tpl = NanNew(New); tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(NanSymbol("Wrapper")); + tpl->SetClassName(NanNew("Wrapper")); NODE_SET_PROTOTYPE_METHOD(tpl, "toBuffer", ToBuffer); - NanAssignPersistent(FunctionTemplate, constructor_template, tpl); - target->Set(String::NewSymbol("Wrapper"), tpl->GetFunction()); + NanAssignPersistent(constructor_template, tpl); + target->Set(NanNew("Wrapper"), tpl->GetFunction()); } NAN_METHOD(Wrapper::New) { NanScope(); if (args.Length() == 0 || !args[0]->IsExternal()) { - return NanThrowError(String::New("void * is required.")); + return NanThrowError("void * is required."); } Wrapper* object = new Wrapper(External::Cast(*args[0])->Value()); @@ -44,12 +43,14 @@ NAN_METHOD(Wrapper::New) { } Handle Wrapper::New(void *raw) { - NanScope(); - Handle argv[1] = { External::New((void *)raw) }; + NanEscapableScope(); + + Handle argv[1] = { NanNew((void *)raw) }; Local instance; - Local constructorHandle = NanPersistentToLocal(constructor_template); + Local constructorHandle = NanNew(constructor_template); instance = constructorHandle->GetFunction()->NewInstance(1, argv); - return scope.Close(instance); + + return NanEscapeScope(instance); } void *Wrapper::GetValue() { @@ -60,15 +61,15 @@ NAN_METHOD(Wrapper::ToBuffer) { NanScope(); if(args.Length() == 0 || !args[0]->IsNumber()) { - return NanThrowError(String::New("Number is required.")); + return NanThrowError("Number is required."); } int len = args[0]->ToNumber()->Value(); Local bufferConstructor = Local::Cast( - Context::GetCurrent()->Global()->Get(String::New("Buffer"))); + NanGetCurrentContext()->Global()->Get(NanNew("Buffer"))); - Handle constructorArgs[1] = { Integer::New(len) }; + Handle constructorArgs[1] = { NanNew(len) }; Local nodeBuffer = bufferConstructor->NewInstance(1, constructorArgs); std::memcpy(node::Buffer::Data(nodeBuffer), ObjectWrap::Unwrap(args.This())->GetValue(), len);