nodegit · johnhaley81 · Feb 19, 2015 · Feb 18, 2015 · Feb 18, 2015 · Feb 18, 2015
diff --git a/generate/input/descriptor.json b/generate/input/descriptor.json
@@ -727,7 +727,21 @@
     "index": {
       "functions": {
         "git_index_add_all": {
-          "ignore": true
+          "args": {
+            "pathspec": {
+              "isOptional": true
+            },
+            "flags": {
+              "isOptional": true
+            },
+            "callback": {
+              "isOptional": true
+            }
+          },
+          "isAsync": true,
+          "return": {
+            "isErrorCode": true
+          }
         },
         "git_index_conflict_get": {
           "ignore": true
@@ -780,7 +794,10 @@
 	          }
 	        }
         }
-      }
+      },
+      "dependencies": [
+        "../include/str_array_converter.h"
+      ]
     },
     "index_entry": {
       "ignore": false

diff --git a/generate/scripts/helpers.js b/generate/scripts/helpers.js
@@ -244,10 +244,10 @@ var Helpers = {
     if (Helpers.isCallbackFunction(type)) {
       Helpers.processCallback(arg);
 
-      var argOverrides = argOverrides.args || {};
+      var callBackArgOverrides = argOverrides.args || {};
       arg.args = arg.args || [];
       arg.args.forEach(function (argForCallback) {
-        Helpers.decorateArg(argForCallback, arg.args, null, null, argOverrides[argForCallback.name] || {}, enums);
+        Helpers.decorateArg(argForCallback, arg.args, null, null, callBackArgOverrides[argForCallback.name] || {}, enums);
       });
     }
     else if (typeDef && fnDef) {

diff --git a/...emplates/manual/include/callbackWrapper.h → ...mplates/manual/include/callback_wrapper.h b/...emplates/manual/include/callbackWrapper.h → ...mplates/manual/include/callback_wrapper.h
diff --git a/generate/templates/manual/include/str_array_converter.h b/generate/templates/manual/include/str_array_converter.h
@@ -0,0 +1,22 @@
+#ifndef STR_ARRAY_H
+#define STR_ARRAY_H
+
+#include <v8.h>
+
+#include "nan.h"
+#include "git2/strarray.h"
+
+using namespace v8;
+
+class StrArrayConverter {
+  public:
+
+    static git_strarray *Convert (Handle<v8::Value> val);
+
+  private:
+    static git_strarray *ConvertArray(Array *val);
+    static git_strarray *ConvertString(Handle<String> val);
+    static git_strarray *ConstructStrArray(int argc, char** argv);
+};
+
+#endif
diff --git a/generate/templates/manual/src/str_array_converter.cc b/generate/templates/manual/src/str_array_converter.cc
@@ -0,0 +1,61 @@
+#include <nan.h>
+#include <node.h>
+#include <string>
+#include <cstring>
+
+#include "../include/str_array_converter.h"
+#include "git2/strarray.h"
+
+using namespace v8;
+using namespace node;
+
+git_strarray *StrArrayConverter::Convert(Handle<v8::Value> val) {
+  if (!val->BooleanValue()) {
+    return NULL;
+  }
+  else if (val->IsArray()) {
+    return ConvertArray(Array::Cast(*val));
+  }
+  else if (val->IsString() || val->IsStringObject()) {
+    return ConvertString(val->ToString());
+  }
+  else {
+    return NULL;
+  }
+}
+
+git_strarray *StrArrayConverter::ConvertArray(Array *val) {
+  int count = val->Length();
+  char **strings = (char **)malloc(sizeof(char*) * count);
+  git_strarray *result;
+
+  for(int i = 0; i < count; i++) {
+    NanUtf8String entry(val->CloneElementAt(i));
+    strings[i] = *entry;
+  }
+
+  result = ConstructStrArray(count, strings);
+  free(strings);
+  return result;
+}
+
+git_strarray* StrArrayConverter::ConvertString(Handle<String> val) {
+  char *strings[1];
+  NanUtf8String utf8String(val);
+
+  strings[0] = *utf8String;
+
+  return ConstructStrArray(1, strings);
+}
+
+git_strarray *StrArrayConverter::ConstructStrArray(int argc, char** argv) {
+  git_strarray *result = (git_strarray *)malloc(sizeof(git_strarray*));
+  result->count = argc;
+  result->strings = (char **)malloc(sizeof(char*) * result->count);
+
+  for(size_t i = 0; i < result->count; i++) {
+    result->strings[i] = strdup(argv[i]);
+  }
+
+  return result;
+}
diff --git a/generate/templates/partials/async_function.cc b/generate/templates/partials/async_function.cc
@@ -17,8 +17,14 @@ NAN_METHOD({{ cppClassName }}::{{ cppFunctionName }}) {
       {%if arg.isSelf %}
   baton->{{ arg.name }} = ObjectWrap::Unwrap<{{ arg.cppClassName }}>(args.This())->GetValue();
       {%elsif arg.isCallbackFunction %}
-  baton->{{ arg.name}} = {{ cppFunctionName }}_{{ arg.name }}_cppCallback;
-  baton->{{ arg.payload.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+  if (!args[{{ arg.jsArg }}]->IsFunction()) {
+    baton->{{ arg.name }} = NULL;
+    baton->{{ arg.payload.name }} = NULL;
+  }
+  else {
+    baton->{{ arg.name}} = {{ cppFunctionName }}_{{ arg.name }}_cppCallback;
+    baton->{{ arg.payload.name }} = new NanCallback(args[{{ arg.jsArg }}].As<Function>());
+  }
       {%elsif arg.payloadFor %}
         {%-- payloads are ignored --%}
       {%elsif arg.name %}

diff --git a/generate/templates/partials/convert_from_v8.cc b/generate/templates/partials/convert_from_v8.cc
@@ -3,12 +3,17 @@
   {{ cType }} from_{{ name }};
   {%if isOptional | or isBoolean %}
 
+    {%if cppClassName != 'GitStrarray'%}
   if (args[{{ jsArg }}]->Is{{ cppClassName|cppToV8 }}()) {
+    {%endif%}
   {%endif%}
   {%if cppClassName == 'String'%}
 
   String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString());
   from_{{ name }} = ({{ cType }}) strdup(*{{ name }});
+  {%elsif cppClassName == 'GitStrarray' %}
+
+  from_{{ name }} = StrArrayConverter::Convert(args[{{ jsArg }}]);
   {%elsif cppClassName == 'Wrapper'%}
 
   String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString());
@@ -77,11 +82,12 @@
     from_{{ name }} = args[{{ jsArg }}]->IsTrue() ? 1 : 0;
   }
   {%elsif isOptional %}
+    {%if cppClassName != 'GitStrarray'%}
   }
   else {
     from_{{ name }} = 0;
   }
-
+    {%endif%}
   {%endif%}
 // end convert_from_v8 block
 {%endif%}
diff --git a/generate/templates/partials/guard_arguments.cc b/generate/templates/partials/guard_arguments.cc
@@ -11,6 +11,10 @@
         {%elsif arg.isCallbackFunction %}
   if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->IsFunction()) {
     return NanThrowError("{{arg.jsClassName}} {{arg.name}} is required.");
+  }
+        {%elsif arg.cppClassName == "GitStrarray" %}
+  if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->BooleanValue()) {
+    return NanThrowError("Array, String Object, or string {{arg.name}} is required.");
   }
         {%else%}
   if (args.Length() == {{arg.jsArg}} || !args[{{arg.jsArg}}]->Is{{arg.cppClassName|cppToV8}}()) {

diff --git a/generate/templates/templates/binding.gyp b/generate/templates/templates/binding.gyp
@@ -13,6 +13,7 @@
         "src/nodegit.cc",
         "src/wrapper.cc",
         "src/functions/copy.cc",
+        "src/str_array_converter.cc",
         {% each %}
           {% if type != "enum" %}
             "src/{{ name }}.cc",

diff --git a/lib/index.js b/lib/index.js
@@ -17,4 +17,9 @@ Index.prototype.entries = function() {
   return result;
 };
 
+var addAll = Index.prototype.addAll;
+Index.prototype.addAll = function(pathspec, flags, matchedCallback) {
+  return addAll.call(this, pathspec, flags, matchedCallback, null);
+};
+
 module.exports = Index;
diff --git a/test/tests/index.js b/test/tests/index.js
@@ -1,6 +1,9 @@
 var assert = require("assert");
 var path = require("path");
 var local = path.join.bind(path, __dirname);
+var Promise = require("nodegit-promise");
+var promisify = require("promisify-node");
+var fse = promisify(require("fs-extra"));
 
 describe("Index", function() {
   var Repository = require(local("../../lib/repository"));
@@ -29,4 +32,28 @@ describe("Index", function() {
 
     assert.equal(entries[0].path(), ".gitignore");
   });
+
+  it("can add all entries to the index", function() {
+    var repo = this.repo;
+    var index = this.index;
+    var fileContent = {
+      newFile1: "this has some content",
+      newFile2: "and this will have more content"
+    };
+    var fileNames = Object.keys(fileContent);
+
+    return Promise.all(fileNames.map(function(fileName) {
+      fse.writeFile(path.join(repo.workdir(), fileName), fileContent[fileName]);
+    }))
+    .then(function() {
+      return index.addAll();
+    })
+    .then(function() {
+      var newFiles = index.entries().filter(function(entry) {
+        return ~fileNames.indexOf(entry.path());
+      });
+
+      assert.equal(newFiles.length, 2);
+    });
+  });
 });