From 47a68d222a7fd79c3a4fbc1fdee033fb282e92ef Mon Sep 17 00:00:00 2001 From: Maximiliano Korp Date: Tue, 25 Nov 2014 13:58:42 -0700 Subject: [PATCH 1/3] prettify generated output --- .astylerc | 6 ++++++ generate/index.js | 36 ++++++++++++++++++++++++++++++++++-- package.json | 1 + 3 files changed, 41 insertions(+), 2 deletions(-) create mode 100644 .astylerc diff --git a/.astylerc b/.astylerc new file mode 100644 index 000000000..ef70741d4 --- /dev/null +++ b/.astylerc @@ -0,0 +1,6 @@ +--style=linux +--indent=spaces=2 +--attach-namespaces +--attach-classes +--attach-inlines +--attach-extern-c diff --git a/generate/index.js b/generate/index.js index 23e36792e..a70bca618 100644 --- a/generate/index.js +++ b/generate/index.js @@ -4,6 +4,21 @@ const file = require("./util/file"); const idefs = require("./idefs"); const promisify = require("promisify-node"); const fse = promisify(require("fs-extra")); +const js_beautify = require('js-beautify').js_beautify; +const beautify = function (input) { + return js_beautify(input, { + "brace_style": "end-expand", + "max_preserve_newlines": 2, + "preserve_newlines": true, + "indent_size": 2, + "indent_char": " " + }); +} + + +var exec = promisify(function(command, opts, callback) { + return require("child_process").exec(command, opts, callback); +}); // Customize the delimiters so as to not process `{{{` or `}}}`. combyne.settings.delimiters = { @@ -83,7 +98,7 @@ fse.remove(path.resolve(__dirname, "../src")).then(function() { return fse.copy(path.resolve(__dirname, "./manual/"), path.resolve(__dirname, "../")); }).then(function() { // Write out single purpose templates. - file.write("../binding.gyp", templates.binding.render(enabled)); + file.write("../binding.gyp", beautify(templates.binding.render(enabled))); file.write("../src/nodegit.cc", templates.nodegit.render(enabled)); @@ -106,5 +121,22 @@ fse.remove(path.resolve(__dirname, "../src")).then(function() { } }); - file.write("../lib/enums.js", templates.enums.render(enabled)); + + file.write("../lib/enums.js", beautify(templates.enums.render(enabled))); +}).then(function() { + return exec('command -v astyle').then(function(astyle) { + if (astyle) { + return exec( + 'astyle --options=\".astylerc\" ' + + path.resolve(__dirname, "../src") + "/*.cc " + + path.resolve(__dirname, "../include") + "/*.h" + ).then(function() { + return exec( + 'rm ' + + path.resolve(__dirname, "../src") + "/*.cc.orig " + + path.resolve(__dirname, "../include") + "/*.h.orig " + ); + }); + } + }) }); diff --git a/package.json b/package.json index 9e0ec2a13..465f4a05f 100644 --- a/package.json +++ b/package.json @@ -64,6 +64,7 @@ "fs-extra": "^0.12.0", "lodash": "^2.4.1", "istanbul": "~0.3.2", + "js-beautify": "^1.5.4", "jshint": "~2.5.6", "mocha": "~1.21.4", "nan": "~1.3.0", From 84cd2a01c92040feafdb31cdd01e9dc2219f67f4 Mon Sep 17 00:00:00 2001 From: Maximiliano Korp Date: Tue, 25 Nov 2014 13:59:37 -0700 Subject: [PATCH 2/3] update partial templates --- generate/partials/async_function.cc | 141 +++++---- generate/partials/convert_from_v8.cc | 100 +++--- generate/partials/convert_to_v8.cc | 99 +++--- generate/partials/doc.cc | 24 +- generate/partials/field_accessors.cc | 435 ++++++++++++++------------- generate/partials/fields.cc | 25 +- generate/partials/guard_arguments.cc | 20 +- generate/partials/sync_function.cc | 147 ++++----- 8 files changed, 503 insertions(+), 488 deletions(-) diff --git a/generate/partials/async_function.cc b/generate/partials/async_function.cc index cf6dd38b3..0197c4281 100644 --- a/generate/partials/async_function.cc +++ b/generate/partials/async_function.cc @@ -1,8 +1,9 @@ -{%partial doc .%} +{% partial doc . %} NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) { NanScope(); - {%partial guardArguments .%} + {% partial guardArguments . %} + if (args.Length() == {{args|jsArgsCount}} || !args[{{args|jsArgsCount}}]->IsFunction()) { return NanThrowError("Callback is required and must be a Function."); } @@ -12,87 +13,85 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) { baton->error_code = GIT_OK; baton->error = NULL; - {%each args|argsInfo as arg %} - {%if not arg.isReturn %} - {%if arg.isSelf %} - baton->{{ arg.name }} = ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue(); - {%elsif arg.name %} - {%partial convertFromV8 arg%} - {%if not arg.isPayload %} - baton->{{ arg.name }} = from_{{ arg.name }}; - {%endif%} - {%endif%} - {%elsif arg.shouldAlloc %} - baton->{{ arg.name }} = ({{ arg.cType }})malloc(sizeof({{ arg.cType|replace '*' '' }})); - {%endif%} - {%endeach%} + {% each args|argsInfo as arg %} + {% if not arg.isReturn %} + {% if arg.isSelf %} + baton->{{ arg.name }} = ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue(); + {% elsif arg.name %} + {% partial convertFromV8 arg %} + {% if not arg.isPayload %} + baton->{{ arg.name }} = from_{{ arg.name }}; + {% endif %} + {% endif %} + {% elsif arg.shouldAlloc %} + baton->{{ arg.name }} = ({{ arg.cType }})malloc(sizeof({{ arg.cType|replace '*' '' }})); + {% endif %} + {% endeach %} NanCallback *callback = new NanCallback(Local::Cast(args[{{args|jsArgsCount}}])); {{ cppFunctionName }}Worker *worker = new {{ cppFunctionName }}Worker(baton, callback); - {%each args|argsInfo as arg %} - {%if not arg.isReturn %} - {%if arg.isSelf %} + {% each args|argsInfo as arg %} + {% if not arg.isReturn %} + {% if arg.isSelf %} worker->SaveToPersistent("{{ arg.name }}", args.This()); - {%else%} + {% else %} if (!args[{{ arg.jsArg }}]->IsUndefined() && !args[{{ arg.jsArg }}]->IsNull()) worker->SaveToPersistent("{{ arg.name }}", args[{{ arg.jsArg }}]->ToObject()); - {%endif%} - {%endif%} - {%endeach%} + {% endif %} + {% endif %} + {% endeach %} NanAsyncQueueWorker(worker); NanReturnUndefined(); } +// startexecute {{ cppFunctionName }} void {{ cppClassName }}::{{ cppFunctionName }}Worker::Execute() { - {%if .|hasReturnType %} - {{ return.cType }} result = {{ cFunctionName }}( - {%else%} - {{ cFunctionName }}( - {%endif%} - {%-- Insert Function Arguments --%} - {%each args|argsInfo as arg %} - {%-- turn the pointer into a ref --%} - {%if arg.isReturn|and arg.cType|isDoublePointer %}&{%endif%}baton->{{ arg.name }}{%if not arg.lastArg %},{%endif%} - - {%endeach%} - ); - - {%if return.isErrorCode %} - baton->error_code = result; - - if (result != GIT_OK && giterr_last() != NULL) { - baton->error = git_error_dup(giterr_last()); - } - - {%elsif not return.cType == 'void' %} - - baton->result = result; - - {%endif%} + {% if .|hasReturnType %} + {{ return.cType }} result = {{ cFunctionName }} + {% else %} + {{ cFunctionName }} + {% endif %} + ( + + {% each .args|argsInfo as arg %} + {% if arg.isReturn|and arg.cType|isDoublePointer %}&{% endif %}baton->{{ arg.name }}{% if not arg.lastArg %},{% endif %} + {% endeach %} + ); + + {% if return.isErrorCode %} + baton->error_code = result; + + if (result != GIT_OK && giterr_last() != NULL) { + baton->error = git_error_dup(giterr_last()); + } + {% elsif not return.cType == 'void' %} + baton->result = result; + {% endif %} } +// done void {{ cppClassName }}::{{ cppFunctionName }}Worker::HandleOKCallback() { TryCatch try_catch; if (baton->error_code == GIT_OK) { - {%if not .|returnsCount %} + {% if not .|returnsCount %} Handle result = NanUndefined(); - {%else%} + {% else %} Handle to; - {%if .|returnsCount > 1 %} + {% if .|returnsCount > 1 %} Handle result = NanNew(); - {%endif%} - {%each .|returnsInfo 0 1 as _return %} - {%partial convertToV8 _return %} - {%if .|returnsCount > 1 %} + {% endif %} + {% each .|returnsInfo 0 1 as _return %} + {% partial convertToV8 _return %} + {% if .|returnsCount > 1 %} result->Set(NanNew("{{ _return.returnNameOrName }}"), to); - {%endif%} - {%endeach%} - {%if .|returnsCount == 1 %} + {% endif %} + {% endeach %} + {% if .|returnsCount == 1 %} Handle result = to; - {%endif%} - {%endif%} + {% endif %} + {% endif %} Handle argv[2] = { NanNull(), result @@ -111,26 +110,26 @@ void {{ cppClassName }}::{{ cppFunctionName }}Worker::HandleOKCallback() { callback->Call(0, NULL); } - {%each args as arg %} - {%if arg.shouldAlloc %} + {% each args as arg %} + {% if arg.shouldAlloc %} free((void*)baton->{{ arg.name }}); - {%endif%} - {%endeach%} + {% endif %} + {% endeach %} } if (try_catch.HasCaught()) { node::FatalException(try_catch); } - {%each args|argsInfo as arg %} - {%if arg.isCppClassStringOrArray %} - {%if arg.freeFunctionName %} + {% each args|argsInfo as arg %} + {% if arg.isCppClassStringOrArray %} + {% if arg.freeFunctionName %} {{ arg.freeFunctionName }}(baton->{{ arg.name }}); - {%else%} + {% else %} free((void *)baton->{{ arg.name }}); - {%endif%} - {%endif%} - {%endeach%} + {% endif %} + {% endif %} + {% endeach %} delete baton; } diff --git a/generate/partials/convert_from_v8.cc b/generate/partials/convert_from_v8.cc index 788f24e27..45128e591 100644 --- a/generate/partials/convert_from_v8.cc +++ b/generate/partials/convert_from_v8.cc @@ -1,51 +1,53 @@ -{%if not isPayload %} +{% if not isPayload %} {{ cType }} from_{{ name }}; - {%if isOptional %} - - if (args[{{ jsArg }}]->Is{{ cppClassName|cppToV8 }}()) { - {%endif%} - {%if cppClassName == 'String'%} - - String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString()); - from_{{ name }} = ({{ cType }}) strdup(*{{ name }}); - {%elsif cppClassName == 'Wrapper'%} - - String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString()); - from_{{ name }} = ({{ cType }}) strdup(*{{ name }}); - {%elsif cppClassName == 'Array'%} - - Array *tmp_{{ name }} = Array::Cast(*args[{{ jsArg }}]); - from_{{ name }} = ({{ cType }})malloc(tmp_{{ name }}->Length() * sizeof({{ cType|replace '**' '*' }})); - for (unsigned int i = 0; i < tmp_{{ name }}->Length(); i++) { - {%-- - // FIXME: should recursively call convertFromv8. - --%} + {% if isOptional %} + if (args[{{ jsArg }}]->Is{{ cppClassName|cppToV8 }}()) { + {% endif %} + + {% if cppClassName == 'String' %} + + String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString()); + from_{{ name }} = ({{ cType }}) strdup(*{{ name }}); + + {% elsif cppClassName == 'Wrapper' %} + + String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString()); + from_{{ name }} = ({{ cType }}) strdup(*{{ name }}); + + {% elsif cppClassName == 'Array' %} + + Array *tmp_{{ name }} = Array::Cast(*args[{{ jsArg }}]); + from_{{ name }} = ({{ cType }})malloc(tmp_{{ name }}->Length() * sizeof({{ cType|replace '**' '*' }})); + for (unsigned int i = 0; i < tmp_{{ name }}->Length(); i++) { + + {%-- FIXME: should recursively call convertFromv8. --%} from_{{ name }}[i] = ObjectWrap::Unwrap<{{ arrayElementCppClassName }}>(tmp_{{ name }}->Get(NanNew(static_cast(i)))->ToObject())->GetValue(); - } - {%elsif cppClassName == 'Function'%} - {%elsif cppClassName == 'Buffer'%} - - from_{{ name }} = Buffer::Data(args[{{ jsArg }}]->ToObject()); - {%elsif cppClassName|isV8Value %} - - {%if cType|isPointer %} - *from_{{ name }} = ({{ cType|unPointer }}) {{ cast }} {%if isEnum %}(int){%endif%} args[{{ jsArg }}]->To{{ cppClassName }}()->Value(); - {%else%} - from_{{ name }} = ({{ cType }}) {{ cast }} {%if isEnum %}(int){%endif%} args[{{ jsArg }}]->To{{ cppClassName }}()->Value(); - {%endif%} - {%else%} - {%if cType|isDoublePointer %} - from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetRefValue(); - {%else%} - from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetValue(); - {%endif%} - {%endif%} - - {%if isOptional %} - } - else { - from_{{ name }} = 0; - } - - {%endif%} -{%endif%} + } + {% elsif cppClassName == 'Function' %} + + {% elsif cppClassName == 'Buffer' %} + + from_{{ name }} = Buffer::Data(args[{{ jsArg }}]->ToObject()); + + {% elsif cppClassName|isV8Value %} + {% if cType|isPointer %} + *from_{{ name }} = ({{ cType|unPointer }}) {{ cast }} {% if isEnum %}(int){% endif %} args[{{ jsArg }}]->To{{ cppClassName }}()->Value(); + {% else %} + from_{{ name }} = ({{ cType }}) {{ cast }} {% if isEnum %}(int){% endif %} args[{{ jsArg }}]->To{{ cppClassName }}()->Value(); + {% endif %} + {% else %} + {% if cType|isDoublePointer %} + from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetRefValue(); + {% else %} + from_{{ name }} = ObjectWrap::Unwrap<{{ cppClassName }}>(args[{{ jsArg }}]->ToObject())->GetValue(); + {% endif %} + {% endif %} + + {% if isOptional %} + } + else { + from_{{ name }} = 0; + } + + {% endif %} +{% endif %} diff --git a/generate/partials/convert_to_v8.cc b/generate/partials/convert_to_v8.cc index fd2802a0d..1d2053791 100644 --- a/generate/partials/convert_to_v8.cc +++ b/generate/partials/convert_to_v8.cc @@ -1,60 +1,65 @@ // start convert_to_v8 block -{%if cppClassName == 'String' %} +{% if cppClassName == 'String' %} if ({{= parsedName =}}){ - {%if size %} - to = NanNew({{= parsedName =}}, {{ size }}); - {%elsif cType == 'char **' %} - - to = NanNew(*{{= parsedName =}}); - {%else%} - to = NanNew({{= parsedName =}}); - {%endif%} + {% if size %} + to = NanNew({{= parsedName =}}, {{ size }}); + {% elsif cType == 'char **' %} + to = NanNew(*{{= parsedName =}}); + {% else %} + to = NanNew({{= parsedName =}}); + {% endif %} } else { to = NanNull(); } - {%if freeFunctionName %} -{{ freeFunctionName }}({{= parsedName =}}); - {%endif%} -{%elsif cppClassName|isV8Value %} - {%if isCppClassIntType %} -to = NanNew<{{ cppClassName }}>(({{ parsedClassName }}){{= parsedName =}}); - {%else%} - to = NanNew<{{ cppClassName }}>({{= parsedName =}}); - {%endif%} -{%elsif cppClassName == 'External' %} -to = NanNew((void *){{= parsedName =}}); -{%elsif cppClassName == 'Array' %} -{%-- - // FIXME this is not general purpose enough. ---%} -{%if size%} -Local tmpArray = NanNew({{= parsedName =}}->{{ size }}); -for (unsigned int i = 0; i < {{= parsedName =}}->{{ size }}; i++) { - tmpArray->Set(NanNew(i), NanNew({{= parsedName =}}->{{ key }}[i])); -} -{%else%} -Local tmpArray = NanNew({{= parsedName =}}); -{%endif%} -to = tmpArray; -{%else%} - {%if copy %} - if ({{= parsedName =}} != NULL) { - {{= parsedName =}} = ({{ cType|replace '**' '*' }} {%if not cType|isPointer %}*{%endif%}){{ copy }}({{= parsedName =}}); - } - {%endif%} + {% if freeFunctionName %} + {{ freeFunctionName }}({{= parsedName =}}); + {% endif %} + +{% elsif cppClassName|isV8Value %} + + {% if isCppClassIntType %} + to = NanNew<{{ cppClassName }}>(({{ parsedClassName }}){{= parsedName =}}); + {% else %} + to = NanNew<{{ cppClassName }}>({{= parsedName =}}); + {% endif %} + +{% elsif cppClassName == 'External' %} + + to = NanNew((void *){{= parsedName =}}); + +{% elsif cppClassName == 'Array' %} + + {%-- // FIXME this is not general purpose enough. --%} + {% if size %} + Local tmpArray = NanNew({{= parsedName =}}->{{ size }}); + for (unsigned int i = 0; i < {{= parsedName =}}->{{ size }}; i++) { + tmpArray->Set(NanNew(i), NanNew({{= parsedName =}}->{{ key }}[i])); + } + {% else %} + Local tmpArray = NanNew({{= parsedName =}}); + {% endif %} + to = tmpArray; +{% else %} + {% if copy %} if ({{= parsedName =}} != NULL) { - // {{= cppClassName }} {{= parsedName }} - {%if cppClassName == 'Wrapper' %} + {{= parsedName =}} = ({{ cType|replace '**' '*' }} {% if not cType|isPointer %}*{% endif %}){{ copy }}({{= parsedName =}}); + } + {% endif %} + + if ({{= parsedName =}} != NULL) { + // {{= cppClassName }} {{= parsedName }} + {% if cppClassName == 'Wrapper' %} to = {{ cppClassName }}::New((void *){{= parsedName =}}); - {%else%} + {% else %} to = {{ cppClassName }}::New((void *){{= parsedName =}}, false); - {%endif%} - } else { - to = NanNull(); - } + {% endif %} + } + else { + to = NanNull(); + } -{%endif%} +{% endif %} // end convert_to_v8 block diff --git a/generate/partials/doc.cc b/generate/partials/doc.cc index 158a48113..53094312b 100644 --- a/generate/partials/doc.cc +++ b/generate/partials/doc.cc @@ -1,15 +1,15 @@ -/** -{%each args as arg %} - {%if not arg.isReturn %} - {%if not arg.isSelf %} +/* +{% each args as arg %} + {% if not arg.isReturn %} + {% if not arg.isSelf %} * @param {{ arg.jsClassName }} {{ arg.name }} - {%endif%} - {%endif%} -{%endeach%}{%each .|returnsInfo as returnInfo %} - {%if isAsync %} + {% endif %} + {% endif %} +{% endeach %}{% each .|returnsInfo as returnInfo %} + {% if isAsync %} * @param {{ returnInfo.jsOrCppClassName }} callback - {%else%} - * @return {{ returnInfo.jsOrCppClassName }} {%if returnInfo.name %}{{ returnInfo.name }}{%else%}result{%endif%} - {%endif%} -{%endeach%} + {% else %} + * @return {{ returnInfo.jsOrCppClassName }} {% if returnInfo.name %}{{ returnInfo.name }}{% else %}result{% endif %} + {% endif %} +{% endeach %} */ diff --git a/generate/partials/field_accessors.cc b/generate/partials/field_accessors.cc index a5b629026..a980f4b22 100644 --- a/generate/partials/field_accessors.cc +++ b/generate/partials/field_accessors.cc @@ -1,217 +1,224 @@ -{%each fields|fieldsInfo as field %} - {%if not field.ignore %} - -NAN_GETTER({{ cppClassName }}::Get{{ field.cppFunctionName }}) { - NanScope(); - - {{ cppClassName }} *wrapper = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This()); - - {%if field.isEnum %} - NanReturnValue(NanNew((int)wrapper->GetValue()->{{ field.name }})); - {%elsif field.isLibgitType | or field.payloadFor %} - NanReturnValue(wrapper->{{ field.name }}); - {%elsif field.isCallbackFunction %} - NanReturnValue(wrapper->{{ field.name }}->GetFunction()); - {%elsif field.cppClassName == 'String' %} - if (wrapper->GetValue()->{{ field.name }}) { - NanReturnValue(NanNew(wrapper->GetValue()->{{ field.name }})); - } - else { - NanReturnUndefined(); - } - {%elsif field.cppClassName|isV8Value %} - NanReturnValue(NanNew<{{ field.cppClassName }}>(wrapper->GetValue()->{{ field.name }})); - {%endif%} -} - -NAN_SETTER({{ cppClassName }}::Set{{ field.cppFunctionName }}) { - NanScope(); - - {{ cppClassName }} *wrapper = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This()); - - {%if field.isEnum %} - if (value->IsNumber()) { - wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) value->Int32Value(); - } - - {%elsif field.isLibgitType %} - NanDisposePersistent(wrapper->{{ field.name }}); - - wrapper->raw->{{ field.name }} = {%if not field.cType | isPointer %}*{%endif%}ObjectWrap::Unwrap<{{ field.cppClassName }}>(value->ToObject())->GetValue(); - {%elsif field.isCallbackFunction %} - if (value->IsFunction()) { - wrapper->{{ field.name }} = new NanCallback(value.As()); - } - {%elsif field.payloadFor %} - NanAssignPersistent(wrapper->{{ field.name }}, value); - {%elsif field.cppClassName == 'String' %} - if (wrapper->GetValue()->{{ field.name }}) { - //free(wrapper->{{ field.name }}); - } - - String::Utf8Value str(value); - wrapper->GetValue()->{{ field.name }} = strdup(*str); - {%elsif field.isCppClassIntType%} - if (value->IsNumber()) { - wrapper->GetValue()->{{ field.name }} = value->{{field.cppClassName}}Value(); - } - {%else%} - if (value->IsNumber()) { - wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) value->Int32Value(); - } - {%endif%} -} - - {%if field.isCallbackFunction %} -{{ field.returnType }} {{ cppClassName }}::{{ field.name }}_cppCallback ( - {%each field.args|argsInfo as arg%} - {{ arg.cType }} {{ arg.name}}{%if not arg.lastArg %},{%endif%} - - {%endeach%} - ) { - {{ field.name|titleCase }}Baton* baton = new {{ field.name|titleCase }}Baton(); - - {%each field.args|argsInfo as arg %} - baton->{{ arg.name }} = {{ arg.name }}; - {%endeach%} - baton->req.data = baton; - baton->done = false; - - uv_queue_work(uv_default_loop(), &baton->req, {{ field.name }}_asyncWork, {{ field.name }}_asyncAfter); - - while(!baton->done) { - this_thread::sleep_for(chrono::milliseconds(1)); - } - - {%each field|returnsInfo true false as _return %} - *{{ _return.name }} = *baton->{{ _return.name }}; - {%endeach%} - - return baton->result; -} - -void {{ cppClassName }}::{{ field.name }}_asyncWork(uv_work_t* req) { - // We aren't doing any work on a seperate thread, just need to - // access the main node thread in the async after method. - // However, this worker method is still needed -} - -void {{ cppClassName }}::{{ field.name }}_asyncAfter(uv_work_t* req, int status) { - NanScope(); - - {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data); - {{ cppClassName }}* instance = static_cast<{{ cppClassName }}*>(baton->payload); - - if (instance->{{ field.name }}->IsEmpty()) { - {%if field.returnType == "int" %} - baton->result = {{ field.returnNoResults }}; // no results acquired - {%endif%} - baton->done = true; - return; - } - - Local argv[{{ field.args|jsArgsCount }}] = { - {%each field.args|argsInfo as arg %} - {%if arg.name == "payload" %} - {%-- payload is always the last arg --%} - NanNew(instance->{{ fields|payloadFor field.name }}) - {%elsif arg.isJsArg %} - {%if arg.isEnum %} - NanNew((int)baton->{{ arg.name }}), - {%elsif arg.isLibgitType %} - NanNew({{ arg.cppClassName }}::New(&baton->{{ arg.name }}, false)), - {%elsif arg.cType == "size_t" %} - // HACK: NAN should really have an overload for NanNew to support size_t - NanNew((unsigned int)baton->{{ arg.name }}), - {%else%} - NanNew(baton->{{ arg.name }}), - {%endif%} - {%endif%} - {%endeach%} - }; - - TryCatch tryCatch; - Handle result = instance->{{ field.name }}->Call({{ field.args|jsArgsCount }}, argv); - - if (result->IsObject() && result->ToObject()->Has(NanNew("then"))) { - Handle thenProp = result->ToObject()->Get(NanNew("then")); - - if (thenProp->IsFunction()) { - // we can be reasonbly certain that the result is a promise - Local promise = result->ToObject(); - - NanAssignPersistent(baton->promise, promise); - - uv_queue_work(uv_default_loop(), &baton->req, {{ field.name }}_asyncWork, {{ field.name }}_asyncPromisePolling); - return; - } - } - - {{ field.returnType }} resultStatus; - - {%each field|returnsInfo true false as _return%} - if (result.IsEmpty() || result->IsNativeError()) { - baton->result = {{ field.returnError }}; - } - else if (!result->IsNull() && !result->IsUndefined()) { - {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject()); - wrapper->selfFreeing = false; - - baton->{{ _return.name }} = wrapper->GetRefValue(); - baton->result = {{ field.returnSuccess }}; - } - else { - baton->result = {{ field.returnNoResults }}; - } - {%endeach%} - baton->done = true; -} - -void {{ cppClassName }}::{{ field.name }}_asyncPromisePolling(uv_work_t* req, int status) { - NanScope(); - - {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data); - Local promise = NanNew(baton->promise); - NanCallback* isPendingFn = new NanCallback(promise->Get(NanNew("isPending")).As()); - Local argv[1]; // MSBUILD won't assign an array of length 0 - Local isPending = isPendingFn->Call(0, argv)->ToBoolean(); - - if (isPending->Value()) { - uv_queue_work(uv_default_loop(), &baton->req, {{ field.name }}_asyncWork, {{ field.name }}_asyncPromisePolling); - return; - } - - NanCallback* isFulfilledFn = new NanCallback(promise->Get(NanNew("isFulfilled")).As()); - Local isFulfilled = isFulfilledFn->Call(0, argv)->ToBoolean(); - - if (isFulfilled->Value()) { - NanCallback* resultFn = new NanCallback(promise->Get(NanNew("value")).As()); - Handle result = resultFn->Call(0, argv); - {{ field.returnType }} resultStatus; - - {%each field|returnsInfo true false as _return%} - if (result.IsEmpty() || result->IsNativeError()) { - baton->result = {{ field.returnError }}; - } - else if (!result->IsNull() && !result->IsUndefined()) { - {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject()); - wrapper->selfFreeing = false; +{% each fields|fieldsInfo as field %} + {% if not field.ignore %} + NAN_GETTER({{ cppClassName }}::Get{{ field.cppFunctionName }}) { + NanScope(); + + {{ cppClassName }} *wrapper = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This()); + + {% if field.isEnum %} + NanReturnValue(NanNew((int)wrapper->GetValue()->{{ field.name }})); + + {% elsif field.isLibgitType | or field.payloadFor %} + NanReturnValue(wrapper->{{ field.name }}); - baton->{{ _return.name }} = wrapper->GetRefValue(); - baton->result = {{ field.returnSuccess }}; + {% elsif field.isCallbackFunction %} + NanReturnValue(wrapper->{{ field.name }}->GetFunction()); + + {% elsif field.cppClassName == 'String' %} + if (wrapper->GetValue()->{{ field.name }}) { + NanReturnValue(NanNew(wrapper->GetValue()->{{ field.name }})); + } + else { + NanReturnUndefined(); + } + + {% elsif field.cppClassName|isV8Value %} + NanReturnValue(NanNew<{{ field.cppClassName }}>(wrapper->GetValue()->{{ field.name }})); + {% endif %} } - else { - baton->result = {{ field.returnNoResults }}; + + NAN_SETTER({{ cppClassName }}::Set{{ field.cppFunctionName }}) { + NanScope(); + + {{ cppClassName }} *wrapper = ObjectWrap::Unwrap<{{ cppClassName }}>(args.This()); + + {% if field.isEnum %} + if (value->IsNumber()) { + wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) value->Int32Value(); + } + + {% elsif field.isLibgitType %} + NanDisposePersistent(wrapper->{{ field.name }}); + wrapper->raw->{{ field.name }} = {% if not field.cType | isPointer %}*{% endif %}ObjectWrap::Unwrap<{{ field.cppClassName }}>(value->ToObject())->GetValue(); + + {% elsif field.isCallbackFunction %} + if (value->IsFunction()) { + wrapper->{{ field.name }} = new NanCallback(value.As()); + } + + {% elsif field.payloadFor %} + NanAssignPersistent(wrapper->{{ field.name }}, value); + + {% elsif field.cppClassName == 'String' %} + if (wrapper->GetValue()->{{ field.name }}) { + } + + String::Utf8Value str(value); + wrapper->GetValue()->{{ field.name }} = strdup(*str); + + {% elsif field.isCppClassIntType %} + if (value->IsNumber()) { + wrapper->GetValue()->{{ field.name }} = value->{{field.cppClassName}}Value(); + } + + {% else %} + if (value->IsNumber()) { + wrapper->GetValue()->{{ field.name }} = ({{ field.cType }}) value->Int32Value(); + } + {% endif %} } - {%endeach%} - baton->done = true; - } - else { - // promise was rejected - baton->result = {{ field.returnError }}; - baton->done = false; - } -} - {%endif%} - {%endif%} -{%endeach%} + + {% if field.isCallbackFunction %} + {{ field.returnType }} {{ cppClassName }}::{{ field.name }}_cppCallback ( + {% each field.args|argsInfo as arg %} + {{ arg.cType }} {{ arg.name}}{% if not arg.lastArg %},{% endif %} + {% endeach %} + ) { + {{ field.name|titleCase }}Baton* baton = new {{ field.name|titleCase }}Baton(); + + {% each field.args|argsInfo as arg %} + baton->{{ arg.name }} = {{ arg.name }}; + {% endeach %} + + baton->req.data = baton; + baton->done = false; + + uv_queue_work(uv_default_loop(), &baton->req, {{ field.name }}_asyncWork, {{ field.name }}_asyncAfter); + + while(!baton->done) { + this_thread::sleep_for(chrono::milliseconds(1)); + } + + {% each field|returnsInfo true false as _return %} + *{{ _return.name }} = *baton->{{ _return.name }}; + {% endeach %} + + return baton->result; + } + + void {{ cppClassName }}::{{ field.name }}_asyncWork(uv_work_t* req) { + // We aren't doing any work on a seperate thread, just need to + // access the main node thread in the async after method. + // However, this worker method is still needed + } + + void {{ cppClassName }}::{{ field.name }}_asyncAfter(uv_work_t* req, int status) { + NanScope(); + + {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data); + {{ cppClassName }}* instance = static_cast<{{ cppClassName }}*>(baton->payload); + + if (instance->{{ field.name }}->IsEmpty()) { + {% if field.returnType == "int" %} + baton->result = {{ field.returnNoResults }}; // no results acquired + {% endif %} + + baton->done = true; + return; + } + + Local argv[{{ field.args|jsArgsCount }}] = { + {% each field.args|argsInfo as arg %} + {% if arg.name == "payload" %} + {%-- payload is always the last arg --%} + NanNew(instance->{{ fields|payloadFor field.name }}) + {% elsif arg.isJsArg %} + {% if arg.isEnum %} + NanNew((int)baton->{{ arg.name }}), + {% elsif arg.isLibgitType %} + NanNew({{ arg.cppClassName }}::New(&baton->{{ arg.name }}, false)), + {% elsif arg.cType == "size_t" %} + // HACK: NAN should really have an overload for NanNew to support size_t + NanNew((unsigned int)baton->{{ arg.name }}), + {% else %} + NanNew(baton->{{ arg.name }}), + {% endif %} + {% endif %} + {% endeach %} + }; + + TryCatch tryCatch; + Handle result = instance->{{ field.name }}->Call({{ field.args|jsArgsCount }}, argv); + + if (result->IsObject() && result->ToObject()->Has(NanNew("then"))) { + Handle thenProp = result->ToObject()->Get(NanNew("then")); + + if (thenProp->IsFunction()) { + // we can be reasonbly certain that the result is a promise + Local promise = result->ToObject(); + + NanAssignPersistent(baton->promise, promise); + + uv_queue_work(uv_default_loop(), &baton->req, {{ field.name }}_asyncWork, {{ field.name }}_asyncPromisePolling); + return; + } + } + + {{ field.returnType }} resultStatus; + + {% each field|returnsInfo true false as _return %} + if (result.IsEmpty() || result->IsNativeError()) { + baton->result = {{ field.returnError }}; + } + else if (!result->IsNull() && !result->IsUndefined()) { + {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject()); + wrapper->selfFreeing = false; + + baton->{{ _return.name }} = wrapper->GetRefValue(); + baton->result = {{ field.returnSuccess }}; + } + else { + baton->result = {{ field.returnNoResults }}; + } + {% endeach %} + baton->done = true; + } + + void {{ cppClassName }}::{{ field.name }}_asyncPromisePolling(uv_work_t* req, int status) { + NanScope(); + + {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data); + Local promise = NanNew(baton->promise); + NanCallback* isPendingFn = new NanCallback(promise->Get(NanNew("isPending")).As()); + Local argv[1]; // MSBUILD won't assign an array of length 0 + Local isPending = isPendingFn->Call(0, argv)->ToBoolean(); + + if (isPending->Value()) { + uv_queue_work(uv_default_loop(), &baton->req, {{ field.name }}_asyncWork, {{ field.name }}_asyncPromisePolling); + return; + } + + NanCallback* isFulfilledFn = new NanCallback(promise->Get(NanNew("isFulfilled")).As()); + Local isFulfilled = isFulfilledFn->Call(0, argv)->ToBoolean(); + + if (isFulfilled->Value()) { + NanCallback* resultFn = new NanCallback(promise->Get(NanNew("value")).As()); + Handle result = resultFn->Call(0, argv); + {{ field.returnType }} resultStatus; + + {% each field|returnsInfo true false as _return %} + if (result.IsEmpty() || result->IsNativeError()) { + baton->result = {{ field.returnError }}; + } + else if (!result->IsNull() && !result->IsUndefined()) { + {{ _return.cppClassName }}* wrapper = ObjectWrap::Unwrap<{{ _return.cppClassName }}>(result->ToObject()); + wrapper->selfFreeing = false; + + baton->{{ _return.name }} = wrapper->GetRefValue(); + baton->result = {{ field.returnSuccess }}; + } + else { + baton->result = {{ field.returnNoResults }}; + } + {% endeach %} + baton->done = true; + } + else { + // promise was rejected + baton->result = {{ field.returnError }}; + baton->done = false; + } + } + {% endif %} + {% endif %} +{% endeach %} diff --git a/generate/partials/fields.cc b/generate/partials/fields.cc index 45e17503c..82cc8d084 100644 --- a/generate/partials/fields.cc +++ b/generate/partials/fields.cc @@ -1,15 +1,14 @@ -{%each fields|fieldsInfo as field %} - {%if not field.ignore %} +{% each fields|fieldsInfo as field %} + {% if not field.ignore %} + NAN_METHOD({{ cppClassName }}::{{ field.cppFunctionName }}) { + NanScope(); + Handle to; -NAN_METHOD({{ cppClassName }}::{{ field.cppFunctionName }}) { - NanScope(); - Handle to; + {{ field.cType }} {% if not field.cppClassName|isV8Value %}*{% endif %}{{ field.name }} = + {% if not field.cppClassName|isV8Value %}&{% endif %}ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue()->{{ field.name }}; - {{ field.cType }} {%if not field.cppClassName|isV8Value %}*{%endif%}{{ field.name }} = - {%if not field.cppClassName|isV8Value %}&{%endif%}ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue()->{{ field.name }}; - - {%partial convertToV8 field %} - NanReturnValue(to); -} - {%endif%} -{%endeach%} + {% partial convertToV8 field %} + NanReturnValue(to); + } + {% endif %} +{% endeach %} diff --git a/generate/partials/guard_arguments.cc b/generate/partials/guard_arguments.cc index 9bc969979..278c5c27a 100644 --- a/generate/partials/guard_arguments.cc +++ b/generate/partials/guard_arguments.cc @@ -1,11 +1,9 @@ - -{%each args|argsInfo as arg%} - {%if arg.isJsArg%} - {%if not arg.isOptional%} - if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->Is{{arg.cppClassName|cppToV8}}()) { - return NanThrowError("{{arg.jsClassName}} {{arg.name}} is required."); - } - - {%endif%} - {%endif%} -{%endeach%} +{% each args|argsInfo as arg %} + {% if arg.isJsArg %} + {% if not arg.isOptional %} + if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->Is{{arg.cppClassName|cppToV8}}()) { + return NanThrowError("{{arg.jsClassName}} {{arg.name}} is required."); + } + {% endif %} + {% endif %} +{% endeach %} diff --git a/generate/partials/sync_function.cc b/generate/partials/sync_function.cc index 042a7d3a3..df627de3b 100644 --- a/generate/partials/sync_function.cc +++ b/generate/partials/sync_function.cc @@ -1,81 +1,86 @@ - -{%partial doc .%} +{% partial doc . %} NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) { NanEscapableScope(); - {%partial guardArguments .%} + {% partial guardArguments . %} + + {% each .|returnsInfo 'true' as _return %} + {% if _return.shouldAlloc %} + {{ _return.cType }}{{ _return.name }} = ({{ _return.cType }})malloc(sizeof({{ _return.cType|unPointer }})); + {% else %} + {{ _return.cType|unPointer }} {{ _return.name }} = {{ _return.cType|unPointer|defaultValue }}; + {% endif %} + {% endeach %} + + {% each args|argsInfo as arg %} + {% if not arg.isSelf %} + {% if not arg.isReturn %} + {% partial convertFromV8 arg %} + {% endif %} + {% endif %} + {% endeach %} - {%each .|returnsInfo 'true' as _return %} - {%if _return.shouldAlloc %} - {{ _return.cType }}{{ _return.name }} = ({{ _return.cType }})malloc(sizeof({{ _return.cType|unPointer }})); - {%else%} - {{ _return.cType|unPointer }} {{ _return.name }} = {{ _return.cType|unPointer|defaultValue }}; - {%endif%} - {%endeach%} + {% if .|hasReturns %} + {{ return.cType }} result = + {% endif %} + {{ cFunctionName }}( + {% each args|argsInfo as arg %} + {% if arg.isReturn %} + {% if not arg.shouldAlloc %}&{% endif %} + {% endif %} + {% if arg.isSelf %} + ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue() + {% elsif arg.isReturn %} + {{ arg.name }} + {% else %} + from_{{ arg.name }} + {% endif %} - {%each args|argsInfo as arg %} - {%if not arg.isSelf %} - {%if not arg.isReturn %} - {%partial convertFromV8 arg %} - {%endif%} - {%endif%} - {%endeach%} + {% if not arg.lastArg %},{% endif %} + {% endeach %} + ); -{%if .|hasReturns %} - {{ return.cType }} result = {%endif%}{{ cFunctionName }}( - {%each args|argsInfo as arg %} - {%if arg.isReturn %} - {%if not arg.shouldAlloc %}&{%endif%} - {%endif%} - {%if arg.isSelf %} -ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue() - {%elsif arg.isReturn %} -{{ arg.name }} - {%else%} -from_{{ arg.name }} - {%endif%} - {%if not arg.lastArg %},{%endif%} - {%endeach%} - ); -{%if return.isErrorCode %} - if (result != GIT_OK) { - {%each args|argsInfo as arg %} - {%if arg.shouldAlloc %} - free({{ arg.name }}); - {%endif%} - {%endeach%} + {% if return.isErrorCode %} + if (result != GIT_OK) { + {% each args|argsInfo as arg %} + {% if arg.shouldAlloc %} + free({{ arg.name }}); + {% endif %} + {% endeach %} - if (giterr_last()) { - return NanThrowError(giterr_last()->message); - } else { - return NanThrowError("Unknown Error"); - } - } -{%endif%} + if (giterr_last()) { + return NanThrowError(giterr_last()->message); + } else { + return NanThrowError("Unknown Error"); + } + } + {% endif %} -{%if not .|returnsCount %} - NanReturnUndefined(); -{%else%} - {%if return.cType | isPointer %} + {% if not .|returnsCount %} + NanReturnUndefined(); + {% else %} + {% if return.cType | isPointer %} // null checks on pointers - if (!result) { - NodeGitPsueodoNanReturnEscapingValue(NanUndefined()); - } - {%endif%} + if (!result) { + NodeGitPsueodoNanReturnEscapingValue(NanUndefined()); + } + {% endif %} + + Handle to; + {% if .|returnsCount > 1 %} + Handle toReturn = NanNew(); + {% endif %} + + {% each .|returnsInfo as _return %} + {% partial convertToV8 _return %} + {% if .|returnsCount > 1 %} + toReturn->Set(NanNew("{{ _return.returnNameOrName }}"), to); + {% endif %} + {% endeach %} - Handle to; - {%if .|returnsCount > 1 %} - Handle toReturn = NanNew(); - {%endif%} - {%each .|returnsInfo as _return %} - {%partial convertToV8 _return %} - {%if .|returnsCount > 1 %} - toReturn->Set(NanNew("{{ _return.returnNameOrName }}"), to); - {%endif%} - {%endeach%} - {%if .|returnsCount == 1 %} - NodeGitPsueodoNanReturnEscapingValue(to); - {%else%} - NodeGitPsueodoNanReturnEscapingValue(toReturn); - {%endif%} -{%endif%} + {% if .|returnsCount == 1 %} + NodeGitPsueodoNanReturnEscapingValue(to); + {% else %} + NodeGitPsueodoNanReturnEscapingValue(toReturn); + {% endif %} + {% endif %} } From 3166ea922f4753d4d0d605bf94179557cc71138f Mon Sep 17 00:00:00 2001 From: Maximiliano Korp Date: Tue, 25 Nov 2014 14:00:17 -0700 Subject: [PATCH 3/3] clean up primary templates --- generate/templates/binding.gyp | 9 +- generate/templates/class_content.cc | 197 ++++++++++++++------------- generate/templates/class_header.h | 146 ++++++++++---------- generate/templates/enums.js | 17 +-- generate/templates/nodegit.cc | 8 +- generate/templates/struct_content.cc | 81 +++++------ generate/templates/struct_header.h | 97 +++++++------ 7 files changed, 284 insertions(+), 271 deletions(-) diff --git a/generate/templates/binding.gyp b/generate/templates/binding.gyp index 10f292de3..6e287b408 100644 --- a/generate/templates/binding.gyp +++ b/generate/templates/binding.gyp @@ -1,4 +1,5 @@ -# This is a generated file, modify: generate/templates/binding.gyp. +# // This is a generated file, modify: generate/templates/binding.gyp. + { "targets": [ { @@ -12,11 +13,11 @@ "src/nodegit.cc", "src/wrapper.cc", "src/functions/copy.cc", - {%each%} + {% each %} {% if type != "enum" %} - "src/{{ name }}.cc", + "src/{{ name }}.cc", {% endif %} - {%endeach%} + {% endeach %} ], "include_dirs": [ diff --git a/generate/templates/class_content.cc b/generate/templates/class_content.cc index a4be2bf63..538b10940 100644 --- a/generate/templates/class_content.cc +++ b/generate/templates/class_content.cc @@ -3,10 +3,10 @@ #include extern "C" { -#include -{%each cDependencies as dependency %} -#include <{{ dependency }}> -{%endeach%} + #include + {% each cDependencies as dependency %} + #include <{{ dependency }}> + {% endeach %} } @@ -14,9 +14,9 @@ extern "C" { #include "../include/macros.h" #include "../include/{{ filename }}.h" -{%each dependencies as dependency%} -#include "{{ dependency }}" -{%endeach%} +{% each dependencies as dependency %} + #include "{{ dependency }}" +{% endeach %} #include @@ -24,107 +24,110 @@ using namespace std; using namespace v8; using namespace node; -{%if cType%} -{{ cppClassName }}::{{ cppClassName }}({{ cType }} *raw, bool selfFreeing) { - this->raw = raw; - this->selfFreeing = selfFreeing; -} +{% if cType %} + {{ cppClassName }}::{{ cppClassName }}({{ cType }} *raw, bool selfFreeing) { + this->raw = raw; + this->selfFreeing = selfFreeing; + } -{{ cppClassName }}::~{{ cppClassName }}() { - {%if freeFunctionName%} - if (this->selfFreeing) { - {{ freeFunctionName }}(this->raw); + {{ cppClassName }}::~{{ cppClassName }}() { + {% if freeFunctionName %} + if (this->selfFreeing) { + {{ freeFunctionName }}(this->raw); + } + {% endif %} } - {%endif%} -} -void {{ cppClassName }}::InitializeComponent(Handle target) { - NanScope(); - - Local tpl = NanNew(New); - - tpl->InstanceTemplate()->SetInternalFieldCount(1); - tpl->SetClassName(NanNew("{{ jsClassName }}")); - - {%each functions as function%} - {%if not function.ignore%} - {%if function.isPrototypeMethod%} - NODE_SET_PROTOTYPE_METHOD(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }}); - {%else%} - NODE_SET_METHOD(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }}); - {%endif%} - {%endif%} - {%endeach%} - - {%each fields as field%} - {%if not field.ignore%} - NODE_SET_PROTOTYPE_METHOD(tpl, "{{ field.jsFunctionName }}", {{ field.cppFunctionName }}); - {%endif%} - {%endeach%} - - Local _constructor_template = tpl->GetFunction(); - NanAssignPersistent(constructor_template, _constructor_template); - target->Set(NanNew("{{ jsClassName }}"), _constructor_template); -} + void {{ cppClassName }}::InitializeComponent(Handle target) { + NanScope(); + + Local tpl = NanNew(New); + + tpl->InstanceTemplate()->SetInternalFieldCount(1); + tpl->SetClassName(NanNew("{{ jsClassName }}")); + + {% each functions as function %} + {% if not function.ignore %} + {% if function.isPrototypeMethod %} + NODE_SET_PROTOTYPE_METHOD(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }}); + {% else %} + NODE_SET_METHOD(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }}); + {% endif %} + {% endif %} + {% endeach %} + + {% each fields as field %} + {% if not field.ignore %} + NODE_SET_PROTOTYPE_METHOD(tpl, "{{ field.jsFunctionName }}", {{ field.cppFunctionName }}); + {% endif %} + {% endeach %} + + Local _constructor_template = tpl->GetFunction(); + NanAssignPersistent(constructor_template, _constructor_template); + target->Set(NanNew("{{ jsClassName }}"), _constructor_template); + } -NAN_METHOD({{ cppClassName }}::New) { - NanScope(); + NAN_METHOD({{ cppClassName }}::New) { + NanScope(); - if (args.Length() == 0 || !args[0]->IsExternal()) { - {%if createFunctionName%} - return NanThrowError("A new {{ cppClassName }} cannot be instantiated. Use {{ jsCreateFunctionName }} instead."); - {%else%} - return NanThrowError("A new {{ cppClassName }} cannot be instantiated."); - {%endif%} + if (args.Length() == 0 || !args[0]->IsExternal()) { + {% if createFunctionName %} + return NanThrowError("A new {{ cppClassName }} cannot be instantiated. Use {{ jsCreateFunctionName }} instead."); + {% else %} + return NanThrowError("A new {{ cppClassName }} cannot be instantiated."); + {% endif %} + } + + {{ cppClassName }}* object = new {{ cppClassName }}(static_cast<{{ cType }} *>(Handle::Cast(args[0])->Value()), args[1]->BooleanValue()); + object->Wrap(args.This()); + + NanReturnValue(args.This()); } - {{ cppClassName }}* object = new {{ cppClassName }}(static_cast<{{ cType }} *>(Handle::Cast(args[0])->Value()), args[1]->BooleanValue()); - object->Wrap(args.This()); + Handle {{ cppClassName }}::New(void *raw, bool selfFreeing) { + NanEscapableScope(); + Handle argv[2] = { NanNew((void *)raw), NanNew(selfFreeing) }; + return NanEscapeScope(NanNew({{ cppClassName }}::constructor_template)->NewInstance(2, argv)); + } - NanReturnValue(args.This()); -} + {{ cType }} *{{ cppClassName }}::GetValue() { + return this->raw; + } -Handle {{ cppClassName }}::New(void *raw, bool selfFreeing) { - NanEscapableScope(); - Handle argv[2] = { NanNew((void *)raw), NanNew(selfFreeing) }; - return NanEscapeScope(NanNew({{ cppClassName }}::constructor_template)->NewInstance(2, argv)); -} + {{ cType }} **{{ cppClassName }}::GetRefValue() { + return &this->raw; + } -{{ cType }} *{{ cppClassName }}::GetValue() { - return this->raw; -} +{% else %} -{{ cType }} **{{ cppClassName }}::GetRefValue() { - return &this->raw; -} -{%else%} -void {{ cppClassName }}::InitializeComponent(Handle target) { - NanScope(); + void {{ cppClassName }}::InitializeComponent(Handle target) { + NanScope(); - Local object = NanNew(); + Local object = NanNew(); - {%each functions as function%} - {%if not function.ignore%} - NODE_SET_METHOD(object, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }}); - {%endif%} - {%endeach%} + {% each functions as function %} + {% if not function.ignore %} + NODE_SET_METHOD(object, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }}); + {% endif %} + {% endeach %} - target->Set(NanNew("{{ jsClassName }}"), object); -} -{%endif%} - -{%each functions as function %} - {%if not function.ignore%} - {%if function.isAsync%} - {%partial asyncFunction function %} - {%else%} - {%partial syncFunction function %} - {%endif%} - {%endif%} -{%endeach%} - -{%partial fields .%} - -{%if not cTypeIsUndefined %} -Persistent {{ cppClassName }}::constructor_template; -{%endif%} + target->Set(NanNew("{{ jsClassName }}"), object); + } + +{% endif %} + +{% each functions as function %} + {% if not function.ignore %} + {% if function.isAsync %} + {% partial asyncFunction function %} + {% else %} + {% partial syncFunction function %} + {% endif %} + {% endif %} +{% endeach %} + +{% partial fields . %} + +{% if not cTypeIsUndefined %} + Persistent {{ cppClassName }}::constructor_template; +{% endif %} diff --git a/generate/templates/class_header.h b/generate/templates/class_header.h index ab0615362..0e23d702f 100644 --- a/generate/templates/class_header.h +++ b/generate/templates/class_header.h @@ -5,26 +5,26 @@ #include extern "C" { -#include -{%each cDependencies as dependency %} -#include <{{ dependency }}> -{%endeach%} + #include + {% each cDependencies as dependency %} + #include <{{ dependency }}> + {% endeach %} } -{%each dependencies as dependency%} -#include "{{ dependency }}" -{%endeach%} - -{%if needsForwardDeclaration %} -// Forward declaration. -struct {{ cType }} { - {%each fields as field%} - {%if not field.ignore%} - {{ field.structType|or field.cType }} {{ field.structName|or field.name }}; - {%endif%} - {%endeach%} -}; -{%endif%} +{% each dependencies as dependency %} + #include "{{ dependency }}" +{% endeach %} + +{% if needsForwardDeclaration %} + // Forward declaration. + struct {{ cType }} { + {% each fields as field %} + {% if not field.ignore %} + {{ field.structType|or field.cType }} {{ field.structName|or field.name }}; + {% endif %} + {% endeach %} + }; +{% endif %} using namespace node; using namespace v8; @@ -35,66 +35,70 @@ class {{ cppClassName }} : public ObjectWrap { static Persistent constructor_template; static void InitializeComponent (Handle target); - {%if cType%} - {{ cType }} *GetValue(); - {{ cType }} **GetRefValue(); + {% if cType %} + {{ cType }} *GetValue(); + {{ cType }} **GetRefValue(); + + static Handle New(void *raw, bool selfFreeing); + + {% endif %} - static Handle New(void *raw, bool selfFreeing); - {%endif%} bool selfFreeing; private: - {%if cType%} - {{ cppClassName }}({{ cType }} *raw, bool selfFreeing); - ~{{ cppClassName }}(); - {%endif%} + {% if cType %} + {{ cppClassName }}({{ cType }} *raw, bool selfFreeing); + ~{{ cppClassName }}(); + {% endif %} static NAN_METHOD(New); - {%each fields as field%} - {%if not field.ignore%} - static NAN_METHOD({{ field.cppFunctionName }}); - {%endif%} - {%endeach%} - - {%each functions as function%} - {%if not function.ignore%} - {%if function.isAsync%} - - struct {{ function.cppFunctionName }}Baton { - int error_code; - const git_error* error; - {%each function.args as arg%} - {%if arg.isReturn%} - {{ arg.cType|replace "**" "*" }} {{ arg.name }}; - {%else%} - {{ arg.cType }} {{ arg.name }}; - {%endif%} - {%endeach%} - }; - class {{ function.cppFunctionName }}Worker : public NanAsyncWorker { - public: - {{ function.cppFunctionName }}Worker( - {{ function.cppFunctionName }}Baton *_baton, - NanCallback *callback - ) : NanAsyncWorker(callback) - , baton(_baton) {}; - ~{{ function.cppFunctionName }}Worker() {}; - void Execute(); - void HandleOKCallback(); - - private: - {{ function.cppFunctionName }}Baton *baton; - }; - {%endif%} - - static NAN_METHOD({{ function.cppFunctionName }}); - {%endif%} - {%endeach%} - - {%if cType%} - {{ cType }} *raw; - {%endif%} + {% each fields as field %} + {% if not field.ignore %} + static NAN_METHOD({{ field.cppFunctionName }}); + {% endif %} + {% endeach %} + + {% each functions as function %} + {% if not function.ignore %} + {% if function.isAsync %} + + struct {{ function.cppFunctionName }}Baton { + int error_code; + const git_error* error; + {% each function.args as arg %} + {% if arg.isReturn %} + {{ arg.cType|replace "**" "*" }} {{ arg.name }}; + {% else %} + {{ arg.cType }} {{ arg.name }}; + {% endif %} + {% endeach %} + }; + + class {{ function.cppFunctionName }}Worker : public NanAsyncWorker { + public: + {{ function.cppFunctionName }}Worker( + {{ function.cppFunctionName }}Baton *_baton, + NanCallback *callback + ) : NanAsyncWorker(callback) + , baton(_baton) {}; + ~{{ function.cppFunctionName }}Worker() {}; + void Execute(); + void HandleOKCallback(); + + private: + {{ function.cppFunctionName }}Baton *baton; + + }; + {% endif %} + + static NAN_METHOD({{ function.cppFunctionName }}); + {% endif %} + {% endeach %} + + {% if cType %} + {{ cType }} *raw; + {% endif %} }; #endif diff --git a/generate/templates/enums.js b/generate/templates/enums.js index 210ddcf91..f9823800a 100644 --- a/generate/templates/enums.js +++ b/generate/templates/enums.js @@ -1,16 +1,13 @@ var NodeGit = require("../"); NodeGit.Enums = {}; -/* jshint ignore:start */ {% each . as enumerable %} -{% if enumerable.type == "enum" %} -NodeGit.{{ enumerable.owner }}.{{ enumerable.JsName }} = { -{% each enumerable.values as value %} - {{ value.JsName }}: {{ value.value }}, -{% endeach %} -}; + {% if enumerable.type == "enum" %} + NodeGit.{{ enumerable.owner }}.{{ enumerable.JsName }} = { + {% each enumerable.values as value %} + {{ value.JsName }}: {{ value.value }}, + {% endeach %} + }; -{% endif %} + {% endif %} {% endeach %} - -/* jshint ignore:end */ diff --git a/generate/templates/nodegit.cc b/generate/templates/nodegit.cc index 5431d753b..9bd2dd89b 100644 --- a/generate/templates/nodegit.cc +++ b/generate/templates/nodegit.cc @@ -7,7 +7,7 @@ #include "../include/functions/copy.h" {% each %} {% if type != "enum" %} -#include "../include/{{ filename }}.h" + #include "../include/{{ filename }}.h" {% endif %} {% endeach %} @@ -15,11 +15,11 @@ extern "C" void init(Handle target) { NanScope(); Wrapper::InitializeComponent(target); - {%each%} + {% each %} {% if type != "enum" %} - {{ cppClassName }}::InitializeComponent(target); + {{ cppClassName }}::InitializeComponent(target); {% endif %} - {%endeach%} + {% endeach %} } NODE_MODULE(nodegit, init) diff --git a/generate/templates/struct_content.cc b/generate/templates/struct_content.cc index fca6cad30..86d850d40 100644 --- a/generate/templates/struct_content.cc +++ b/generate/templates/struct_content.cc @@ -5,23 +5,25 @@ #include extern "C" { -#include -{%each cDependencies as dependency %} -#include <{{ dependency }}> -{%endeach%} + #include + {% each cDependencies as dependency %} + #include <{{ dependency }}> + {% endeach %} } +#include #include "../include/functions/copy.h" #include "../include/{{ filename }}.h" -{%each dependencies as dependency%} -#include "{{ dependency }}" -{%endeach%} -#include +{% each dependencies as dependency %} + #include "{{ dependency }}" +{% endeach %} using namespace v8; using namespace node; using namespace std; + + // generated from struct_content.cc {{ cppClassName }}::{{ cppClassName }}() { {{ cType }} wrappedValue = {{ cType|upper }}_INIT; @@ -47,32 +49,31 @@ using namespace std; } void {{ cppClassName }}::ConstructFields() { - {%each fields|fieldsInfo as field %} - {%if not field.ignore %} - {%if not field.isEnum %} - {%if field.hasConstructor %} - Local {{ field.name }}Temp = {{ field.cppClassName }}::New(&this->raw->{{ field.name }}, false)->ToObject(); - NanAssignPersistent(this->{{ field.name }}, {{ field.name }}Temp); - - {%elsif field.isLibgitType %} - Local {{ field.name }}Temp = {{ field.cppClassName }}::New(&this->raw->{{ field.name }}, false)->ToObject(); - NanAssignPersistent(this->{{ field.name }}, {{ field.name }}Temp); - - {%elsif field.isCallbackFunction %} - - // Set the static method call and set the payload for this function to be - // the current instance - this->raw->{{ field.name }} = ({{ field.cType }}){{ field.name }}_cppCallback; - this->raw->{{ fields|payloadFor field.name }} = (void *)this; - this->{{ field.name }} = new NanCallback(); - {%elsif field.payloadFor %} - - Local {{ field.name }} = NanUndefined(); - NanAssignPersistent(this->{{ field.name }}, {{ field.name }}); - {%endif%} - {%endif%} - {%endif%} - {%endeach%} + {% each fields|fieldsInfo as field %} + {% if not field.ignore %} + {% if not field.isEnum %} + {% if field.hasConstructor |or field.isLibgitType %} + Local {{ field.name }}Temp = {{ field.cppClassName }}::New( + &this->raw->{{ field.name }}, + false + )->ToObject(); + NanAssignPersistent(this->{{ field.name }}, {{ field.name }}Temp); + + {% elsif field.isCallbackFunction %} + + // Set the static method call and set the payload for this function to be + // the current instance + this->raw->{{ field.name }} = ({{ field.cType }}){{ field.name }}_cppCallback; + this->raw->{{ fields|payloadFor field.name }} = (void *)this; + this->{{ field.name }} = new NanCallback(); + {% elsif field.payloadFor %} + + Local {{ field.name }} = NanUndefined(); + NanAssignPersistent(this->{{ field.name }}, {{ field.name }}); + {% endif %} + {% endif %} + {% endif %} + {% endeach %} } void {{ cppClassName }}::InitializeComponent(Handle target) { @@ -83,11 +84,11 @@ void {{ cppClassName }}::InitializeComponent(Handle target) { tpl->InstanceTemplate()->SetInternalFieldCount(1); tpl->SetClassName(NanNew("{{ jsClassName }}")); - {%each fields as field%} - {%if not field.ignore%} - tpl->InstanceTemplate()->SetAccessor(NanNew("{{ field.jsFunctionName }}"), Get{{ field.cppFunctionName}}, Set{{ field.cppFunctionName}}); - {%endif%} - {%endeach%} + {% each fields as field %} + {% if not field.ignore %} + tpl->InstanceTemplate()->SetAccessor(NanNew("{{ field.jsFunctionName }}"), Get{{ field.cppFunctionName}}, Set{{ field.cppFunctionName}}); + {% endif %} + {% endeach %} Local _constructor_template = tpl->GetFunction(); NanAssignPersistent(constructor_template, _constructor_template); @@ -125,6 +126,6 @@ Handle {{ cppClassName }}::New(void* raw, bool selfFreeing) { return &this->raw; } -{%partial fieldAccessors .%} +{% partial fieldAccessors . %} Persistent {{ cppClassName }}::constructor_template; diff --git a/generate/templates/struct_header.h b/generate/templates/struct_header.h index 006dd96d7..be27df33a 100644 --- a/generate/templates/struct_header.h +++ b/generate/templates/struct_header.h @@ -5,15 +5,15 @@ #include extern "C" { -#include -{%each cDependencies as dependency %} -#include <{{ dependency }}> -{%endeach%} + #include + {% each cDependencies as dependency %} + #include <{{ dependency }}> + {% endeach %} } -{%each dependencies as dependency%} -#include "{{ dependency }}" -{%endeach%} +{% each dependencies as dependency %} + #include "{{ dependency }}" +{% endeach %} using namespace node; using namespace v8; @@ -31,29 +31,34 @@ class {{ cppClassName }} : public ObjectWrap { bool selfFreeing; - {%each fields as field %} - {%if not field.ignore %} - {%if field.isCallbackFunction %} - static {{ field.returnType }} {{ field.name }}_cppCallback ( - {%each field.args|argsInfo as arg %} - {{ arg.cType }} {{ arg.name}}{%if not arg.lastArg %},{%endif%} - {%endeach%} - ); - static void {{ field.name }}_asyncWork(uv_work_t* req); - static void {{ field.name }}_asyncAfter(uv_work_t* req, int status); - static void {{ field.name }}_asyncPromisePolling(uv_work_t* req, int status); - struct {{ field.name|titleCase }}Baton { - {%each field.args|argsInfo as arg %} - {{ arg.cType }} {{ arg.name}}; - {%endeach%} - uv_work_t req; - {{ field.returnType }} result; - Persistent promise; - bool done; - }; - {%endif%} - {%endif%} - {%endeach%} + {% each fields as field %} + {% if not field.ignore %} + {% if field.isCallbackFunction %} + static {{ field.returnType }} {{ field.name }}_cppCallback ( + {% each field.args|argsInfo as arg %} + {{ arg.cType }} {{ arg.name}} + {% if not arg.lastArg %} + , + {% endif %} + {% endeach %} + ); + + static void {{ field.name }}_asyncWork(uv_work_t* req); + static void {{ field.name }}_asyncAfter(uv_work_t* req, int status); + static void {{ field.name }}_asyncPromisePolling(uv_work_t* req, int status); + struct {{ field.name|titleCase }}Baton { + {% each field.args|argsInfo as arg %} + {{ arg.cType }} {{ arg.name}}; + {% endeach %} + + uv_work_t req; + {{ field.returnType }} result; + Persistent promise; + bool done; + }; + {% endif %} + {% endif %} + {% endeach %} private: {{ cppClassName }}(); @@ -63,21 +68,23 @@ class {{ cppClassName }} : public ObjectWrap { static NAN_METHOD(New); - {%each fields as field%} - {%if not field.ignore%} - {%if not field.isEnum %} - {%if field.isLibgitType %} - Persistent {{ field.name }}; - {%elsif field.isCallbackFunction %} - NanCallback* {{ field.name }}; - {%elsif field.payloadFor %} - Persistent {{ field.name }}; - {%endif%} - {%endif%} - static NAN_GETTER(Get{{ field.cppFunctionName }}); - static NAN_SETTER(Set{{ field.cppFunctionName }}); - {%endif%} - {%endeach%} + {% each fields as field %} + {% if not field.ignore %} + {% if not field.isEnum %} + {% if field.isLibgitType %} + Persistent {{ field.name }}; + {% elsif field.isCallbackFunction %} + NanCallback* {{ field.name }}; + {% elsif field.payloadFor %} + Persistent {{ field.name }}; + {% endif %} + {% endif %} + + static NAN_GETTER(Get{{ field.cppFunctionName }}); + static NAN_SETTER(Set{{ field.cppFunctionName }}); + + {% endif %} + {% endeach %} {{ cType }} *raw; };