Add generator scripts

These can be cleaned up significantly, these are early prototypes.

Author: orderedlist

generate/index.js

@@ -0,0 +1,13 @@
+var generatedData = require('./lib/generated_data');
+var writeApiDocs = require('./lib/write_api_docs');
+var addConvenienceMethods = require('./lib/add_convenience_methods.js');
+
+var idefsPath = 'generate/nodegit/generate/output/idefs.json';
+var missingtestsPath = 'generate/nodegit/generate/output/missing-tests.json'
+
+var baseData = generatedData(idefsPath, missingtestsPath);
+var fullData;
+
+addConvenienceMethods(baseData).then(function(fullData) {
+  writeApiDocs(fullData);
+});

generate/lib/add_convenience_methods.js

@@ -0,0 +1,62 @@
+var dox = require('dox');
+var Promise = require('bluebird');
+var fs = require('fs-extra');
+var dive = Promise.promisify(require('dive'));
+var changeCase = require('change-case');
+var Path = require('path');
+var setDocDefaults = require('./set_doc_defaults');
+
+var addConvenienceMethods = function(apiData) {
+  return dive('generate/nodegit/lib', {recursive:false}, function(err, path) {
+    var code = fs.readFileSync(path).toString();
+    var className = changeCase.pascalCase(Path.basename(path, '.js'));
+    dox.parseComments(code, {raw: true}).forEach(function(doc) {
+
+      if (!doc.ctx) return;
+
+      var data = {
+        params: [],
+        return: null,
+        isAsync: false,
+        description: doc.description.full
+      }
+
+      doc.tags.forEach(function(tag) {
+        switch(tag.type) {
+          case 'param':
+            data.params.push({
+              "name": tag.name,
+              "types": tag.types,
+              "description": tag.description,
+              "optional": tag.optional
+            });
+            break;
+          case 'return':
+            data.return = {
+              name: tag.name,
+              type: tag.types[0],
+              description: tag.description || null
+            };
+            break;
+          case 'isAsync':
+            if (tag.value == 'true') {
+              data.isAsync = true;
+            }
+            break;
+        }
+      });
+
+      if (doc.ctx.constructor == className) {
+        var obj = setDocDefaults(apiData, className);
+        apiData[className].prototypes[doc.ctx.name] = data;
+      } else if (doc.ctx.receiver == className) {
+        var obj = setDocDefaults(apiData, className);
+        apiData[className].constructors[doc.ctx.name] = data;
+      }
+    });
+  }).then(function() {
+    return apiData;
+  });
+}
+
+module.exports = addConvenienceMethods;

generate/lib/generated_data.js

@@ -0,0 +1,102 @@
+var fs = require('fs-extra');
+var setDocDefaults = require('./set_doc_defaults');
+var changeCase = require('change-case');
+
+var removePointerReferences = function(text) {
+  if (!text) return '';
+  text = text.replace(/a pointer to /ig, '');
+  text = text.replace(/pointer where to store /ig, '');
+  return text
+}
+
+var sanitizeArgName = function(className, comment) {
+  var argName = changeCase.camelCase(className);
+  if (argName == 'number') {
+    argName = 'result';
+  }
+
+  return argName;
+}
+
+var generatedData = function(path, missingTestsPath) {
+  var apiData = {};
+  var generatedJSON = fs.readJsonSync(path);
+
+  if (missingTestsPath) {
+    var missingTests = fs.readJsonSync(missingTestsPath);
+  }
+
+  generatedJSON.forEach(function(item) {
+    switch (item.type) {
+      case 'class':
+      case 'struct':
+        var obj = setDocDefaults(apiData, item.jsClassName);
+        obj.type = item.type
+        obj.hasConstructor = item.hasConstructor || false
+
+        item.functions.forEach(function(func) {
+          data = {
+            params: [],
+            return: {
+              type: func.return.jsClassName,
+              name: sanitizeArgName(func.return.jsClassName, func.return.comment),
+              description: removePointerReferences(func.return.comment)
+            },
+            isAsync: func.isAsync,
+            description: "",
+            experimental: false
+          }
+
+          if (missingTests) {
+            if (missingTests[item.filename].testFileMissing === false) {
+              data.experimental = true;
+            } else {
+              if (missingTests[item.filename].functions.indexOf(item.jsClassName) != -1) {
+                data.experimental = true;
+              }
+            }
+          }
+
+          func.args.forEach(function(arg) {
+            if (arg.isReturn) {
+              data.return = {
+                name: sanitizeArgName(arg.jsClassName, arg.comment),
+                type: arg.jsClassName,
+                description: removePointerReferences(arg.comment)
+              };
+            } else if (!arg.ignore && !arg.isSelf) {
+              data.params.push({
+                "name": arg.name,
+                "types": [arg.jsClassName],
+                "description": arg.comment,
+                "optional": arg.isOptional || false
+              });
+            }
+          });
+
+          if (func.isPrototypeMethod) {
+            obj.prototypes[func.jsFunctionName] = data
+          } else if (func.isConstructorMethod) {
+            obj.constructors[func.jsFunctionName] = data
+          }
+        });
+
+        item.fields.forEach(function(field) {
+          obj.fields[field.name] = field.jsClassName;
+        });
+        break;
+      case 'enum':
+        obj = setDocDefaults(apiData, item.owner);
+
+        var list = obj.enums[item.JsName] = {}
+        item.values.forEach(function(value) {
+          list[value.JsName] = value.value;
+        });
+        break;
+    }
+  });
+
+  return apiData;
+}
+
+module.exports = generatedData;

generate/lib/set_doc_defaults.js

@@ -0,0 +1,14 @@
+var setDocDefaults = function(apiData, className) {
+  if (!apiData[className]) {
+    apiData[className] = {
+      constructors:{},
+      prototypes:{},
+      fields:{},
+      enums:{}
+    };
+  }
+
+  return apiData[className];
+}
+
+module.exports = setDocDefaults;