FazBrowse GitHub Viewer | Trending |
URL:
| Home
Tools: [Download Repo ZIP]   [Original HTTPS Page]

tests pass now, at least · nodegit/nodegit@83ceda5 · GitHub

  1. nodegit
  2. nodegit

Repository navigation

Commit 83ceda5

Browse files
maxkorp
committed
tests pass now, at least
1 parent 6fb8994 commit 83ceda5

2 files changed

Lines changed: 57 additions & 90 deletions

File tree

‎generate/setup.js‎

Lines changed: 25 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,6 @@ libgit2.types.forEach(function(type) {
1818
Array.prototype.push.apply(libgit2.types, supplement.new.types);
1919

2020
var output = [];
21-
var groupNames = [];
2221
var dependencyLookup = {};
2322
var types = [];
2423
var enums = [];
@@ -27,43 +26,36 @@ var enums = [];
2726
var groups = libgit2.groups.reduce(function(memo, group) {
2827
group[1].typeName = group[0];
2928
memo[group[0]] = group[1];
30-
groupNames.push(group[0]);
3129
return memo;
3230
}, {});
3331

3432

35-
// Process each type in the types array into classes and structs and
36-
// decorate the definitions with required data to build the C++ files
33+
// Split each type from the array into classes/structs and enums
34+
// each entry is of type ['name', {definingobject}]
3735
libgit2.types.forEach(function(current) {
38-
var typeName = current[0];
39-
var typeDefOverrides = descriptor.types[typeName] || {};
40-
var typeDef = current[1];
41-
42-
typeDef.typeName = typeName;
36+
current[1].typeName = current[0];
4337

4438
// just log these out to a file for fun
45-
if (typeDef.type === "enum") {
46-
enums.push(typeDef);
39+
if (current[1].type === "enum") {
40+
enums.push(current[1]);
4741
}
4842
else {
49-
types.push(typeDef);
43+
types.push(current[1]);
5044
}
5145
});
5246

53-
enums = _.sortBy(enums, "name");
54-
5547
var previous = "";
56-
enums = enums.reduce(function(enumMemo, enumerable) {
48+
enums = _(enums).sortBy("name").reduce(function(enumMemo, enumerable) {
5749
if (previous == enumerable.typeName) {
58-
console.log('WARNING: duplicate definition for enum ' + enumerable.name +
50+
console.log('WARNING: duplicate definition for enum ' + enumerable.typeName +
5951
". skipped.");
6052
}
6153
else if (!enumerable.fields) {
62-
console.log('WARNING: incomplete definition for enum ' + enumerable.name +
54+
console.log('WARNING: incomplete definition for enum ' + enumerable.typeName +
6355
". skipped.");
6456
}
6557
else {
66-
enumMemo.push({
58+
enumMemo[enumerable.typeName] = {
6759
name: enumerable.typeName.replace(/^git_/, "").replace(/_t$/, ""),
6860
cType: enumerable.typeName,
6961
isMask: (/_t$/).test(enumerable.typeName),
@@ -73,33 +65,28 @@ enums = enums.reduce(function(enumMemo, enumerable) {
7365
value: field.value
7466
}
7567
})
76-
});
68+
};
7769
}
7870

79-
previous = enumerable.name;
71+
previous = enumerable.typeName;
8072
return enumMemo;
81-
}, []);
73+
}, []).valueOf();
8274

75+
// decorate the definitions with required data to build the C++ files
8376
types.forEach(function(typeDef) {
8477
var typeName = typeDef.typeName;
8578
typeDef.cType = typeName;
8679
typeName = typeName.replace("git_", "");
8780
typeDef.typeName = typeName;
8881
dependencyLookup[typeName] = typeName;
8982

90-
typeDef.isClass = utils.isClass(typeName, groupNames);
83+
typeDef.isClass = !!groups[typeName];
9184
typeDef.isStruct = !typeDef.isClass;
9285

93-
utils.decoratePrimaryType(typeDef);
86+
typeDef.functions = groups[typeName] || [];
87+
utils.decoratePrimaryType(typeDef, enums);
9488

95-
if (typeDef.isClass) {
96-
typeDef.functions = groups[typeName];
97-
utils.decorateClass(typeDef);
98-
groups[typeName] = false;
99-
}
100-
else {
101-
utils.decorateStruct(typeDef);
102-
}
89+
groups[typeName] = false;
10390

10491
output.push(typeDef);
10592
});
@@ -115,14 +102,12 @@ for (var groupName in groups) {
115102
functions: groupDef
116103
};
117104

118-
var classDefOverrides = descriptor.types[groupName] || {};
119105
groupDef.isClass = true;
120106
groupDef.isStruct = false;
121107

122108
groupDef.typeName = groupName;
123109
dependencyLookup[groupName] = groupName;
124-
utils.decoratePrimaryType(groupDef);
125-
utils.decorateClass(groupDef, classDefOverrides);
110+
utils.decoratePrimaryType(groupDef, enums);
126111

127112
output.push(groupDef);
128113
}
@@ -164,19 +149,19 @@ output.forEach(function (def) {
164149
// Process enums
165150
enums.forEach(function(enumerable) {
166151
output.some(function(obj) {
167-
if (enumerable.name.indexOf(obj.typeName) == 0) {
152+
if (enumerable.typeName.indexOf(obj.typeName) == 0) {
168153
enumerable.owner = obj.jsClassName;
169154
}
170155
else if (enumerable.owner) {
171156
return true;
172157
}
173158
});
174159

175-
var override = descriptor.enums[enumerable.name] || {};
160+
var override = descriptor.enums[enumerable.typeName] || {};
176161

177162
enumerable.owner = enumerable.owner || "Enums";
178163

179-
enumerable.JsName = enumerable.name
164+
enumerable.JsName = enumerable.typeName
180165
.replace(new RegExp("^" + enumerable.owner.toLowerCase()), "")
181166
.replace(/^_/, "")
182167
.toUpperCase();
@@ -212,6 +197,9 @@ if (process.argv[2] != "--documentation") {
212197
utils.filterDocumentation(output);
213198
}
214199

200+
fs.writeFileSync(path.join(__dirname, "output.json"),
201+
JSON.stringify(output, null, 2));
202+
215203
output = {types: output, enums: enums};
216204

217205
fs.writeFileSync(path.join(__dirname, "idefs.json"),

‎generate/utils.js‎

Lines changed: 32 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -105,10 +105,6 @@ var Utils = {
105105
&& ~cbField.name.indexOf(payloadName.replace("_payload", ""));
106106
},
107107

108-
isClass: function(typeName, groupNames) {
109-
return !!~groupNames.indexOf(typeName);
110-
},
111-
112108
getLibgitType: function(normalizedType, types) {
113109
var libgitType;
114110

@@ -153,7 +149,7 @@ var Utils = {
153149
}
154150
},
155151

156-
decorateLibgitType: function(type, types) {
152+
decorateLibgitType: function(type, types, enums) {
157153
var normalizedType = Utils.normalizeCtype(type.cType);
158154
var libgitType = Utils.getLibgitType(normalizedType, types);
159155

@@ -166,69 +162,52 @@ var Utils = {
166162
if (type.isEnum) {
167163
type.cppClassName = "Number";
168164
type.jsClassName = "Number";
165+
if (enums[type.cType]) {
166+
type.isMask = enums[type.cType].isMask || false
167+
}
169168
}
170-
171169
_.merge(type, descriptor.types[normalizedType.replace("git_", "")] || {});
172170
}
173171
},
174172

175-
decoratePrimaryType: function(typeDef) {
173+
decoratePrimaryType: function(typeDef, enums) {
176174
var typeDefOverrides = descriptor.types[typeDef.typeName] || {};
177175
var partialOverrides = _.omit(typeDefOverrides, ["fields", "functions"]);
178176

179177
typeDef.cType = typeDef.cType || null;
180178
typeDef.cppClassName = Utils.cTypeToCppName(typeDef.cType || "git_" + typeDef.typeName);
181179
typeDef.jsClassName = Utils.titleCase(Utils.cTypeToJsName(typeDef.cType || "git_" + typeDef.typeName));
182-
183-
typeDef.dependencies = [];
184180
typeDef.filename = typeDef.typeName;
181+
typeDef.isLibgitType = true;
182+
typeDef.dependencies = [];
185183

186184
typeDef.fields = typeDef.fields || [];
187-
188185
typeDef.fields.forEach(function (field, index, allFields) {
189186
var fieldOverrides = typeDefOverrides.fields || {};
190-
Utils.decorateField(field, allFields, fieldOverrides[field.name] || {});
187+
Utils.decorateField(field, allFields, fieldOverrides[field.name] || {}, enums);
191188
});
192189

193190
typeDef.needsForwardDeclaration = typeDef.decl === typeDef.cType;
194191

195-
_.merge(typeDef, partialOverrides);
196-
},
192+
var normalizedType = Utils.normalizeCtype(typeDef.cType);
193+
typeDef.hasConstructor = Utils.hasConstructor(typeDef, normalizedType);
197194

198-
decorateStruct: function(structDef) {
199-
/* There are no enums for now, and when we get there I'm gonna argue they should have
200-
their own process
201-
if (structDef.type === "enum") {
202-
structDef.isEnum = true;
203-
structDef.cppClassName = "Number";
204-
structDef.jsClassName = "Number";
205-
} */
206-
207-
structDef.isLibgitType = true;
208-
209-
// TODO: Structs don't *have* functions, we need to remove the code thats requiring this (if there even is any)
210-
structDef.functions = [];
211-
212-
var normalizedType = Utils.normalizeCtype(structDef.cType);
213-
structDef.hasConstructor = Utils.hasConstructor(structDef, normalizedType);
214-
},
215-
216-
decorateClass: function(classDef) {
217-
var typeDefOverrides = descriptor.types[classDef.typeName] || {};
218-
219-
classDef.functions = (classDef.functions || []).map(function(fn) {
195+
typeDef.functions = (typeDef.functions).map(function(fn) {
220196
var fnDef = libgit2.functions[fn];
221197
fnDef.cFunctionName = fn;
222198
return fnDef;
223199
});
224200

201+
var typeDefOverrides = descriptor.types[typeDef.typeName] || {};
225202
var functionOverrides = typeDefOverrides.functions || {};
226-
classDef.functions.forEach(function(fnDef) {
227-
Utils.decorateFunction(fnDef, classDef, functionOverrides[fnDef.cFunctionName] || {});
203+
typeDef.functions.forEach(function(fnDef) {
204+
Utils.decorateFunction(fnDef, typeDef, functionOverrides[fnDef.cFunctionName] || {}, enums);
228205
});
206+
207+
_.merge(typeDef, partialOverrides);
229208
},
230209

231-
decorateField: function(field, allFields, fieldOverrides) {
210+
decorateField: function(field, allFields, fieldOverrides, enums) {
232211
var normalizeType = Utils.normalizeCtype(field.type);
233212

234213
field.cType = field.type;
@@ -243,7 +222,7 @@ var Utils = {
243222
var argOverrides = fieldOverrides.args || {};
244223
field.args = field.args || [];
245224
field.args.forEach(function (arg) {
246-
Utils.decorateArg(arg, null, null, argOverrides[arg.name] || {});
225+
Utils.decorateArg(arg, null, null, argOverrides[arg.name] || {}, enums);
247226
});
248227
}
249228
else {
@@ -254,26 +233,26 @@ var Utils = {
254233
}
255234
}
256235

257-
Utils.decorateLibgitType(field, libgit2.types);
236+
Utils.decorateLibgitType(field, libgit2.types, enums);
258237
_.merge(field, fieldOverrides);
259238
},
260239

261-
decorateArg: function(arg, classDef, fnDef, argOverrides) {
240+
decorateArg: function(arg, typeDef, fnDef, argOverrides, enums) {
262241
var type = arg.cType || arg.type;
263242
var normalizedType = Utils.normalizeCtype(type);
264243

265244
arg.cType = type;
266245
arg.cppClassName = Utils.cTypeToCppName(arg.cType);
267246
arg.jsClassName = Utils.titleCase(Utils.cTypeToJsName(arg.cType));
268247

269-
Utils.decorateLibgitType(arg, libgit2.types);
248+
Utils.decorateLibgitType(arg, libgit2.types, enums);
270249

271-
if (classDef && fnDef) {
250+
if (typeDef && fnDef) {
272251
// Mark all of the args that are either returns or are the object
273252
// itself and determine if this function goes on the prototype
274253
// or is a constructor method.
275-
arg.isReturn = arg.name === "out" || (Utils.isDoublePointer(arg.type) && normalizedType == classDef.cType);
276-
arg.isSelf = Utils.isPointer(arg.type) && normalizedType == classDef.cType;
254+
arg.isReturn = arg.name === "out" || (Utils.isDoublePointer(arg.type) && normalizedType == typeDef.cType);
255+
arg.isSelf = Utils.isPointer(arg.type) && normalizedType == typeDef.cType;
277256

278257
if (arg.isReturn && fnDef.return && fnDef.return.type === "int") {
279258
fnDef.return.isErrorCode = true;
@@ -292,34 +271,34 @@ var Utils = {
292271
_.merge(arg, argOverrides);
293272
},
294273

295-
decorateFunction: function(fnDef, classDef, fnOverrides) {
274+
decorateFunction: function(fnDef, typeDef, fnOverrides, enums) {
296275
var key = fnDef.cFunctionName;
297276

298277
// if this is the free function for the class, make the ref on the class
299278
// and then return since we don't want the free functions publicly
300279
// available
301-
if (key == classDef.cType + "_free") {
302-
classDef.freeFunctionName = key;
280+
if (key == typeDef.cType + "_free") {
281+
typeDef.freeFunctionName = key;
303282
fnDef.ignore = true;
304283
return;
305284
}
306285

307-
fnDef.cppFunctionName = Utils.cTypeToCppName(key, "git_" + classDef.typeName);
308-
fnDef.jsFunctionName = Utils.cTypeToJsName(key, "git_" + classDef.typeName);
286+
fnDef.cppFunctionName = Utils.cTypeToCppName(key, "git_" + typeDef.typeName);
287+
fnDef.jsFunctionName = Utils.cTypeToJsName(key, "git_" + typeDef.typeName);
309288
//fnDef.isAsync = false; // until proven otherwise
310289

311290

312-
if (fnDef.cppFunctionName == classDef.cppClassName) {
291+
if (fnDef.cppFunctionName == typeDef.cppClassName) {
313292
fnDef.cppFunctionName = fnDef.cppFunctionName.replace("Git", "");
314293
}
315294

316295
var argOverrides = fnOverrides.args || {};
317296
fnDef.args.forEach(function(arg) {
318-
Utils.decorateArg(arg, classDef, fnDef, argOverrides[arg.name] || {});
297+
Utils.decorateArg(arg, typeDef, fnDef, argOverrides[arg.name] || {}, enums);
319298
});
320299

321300
if (fnDef.return) {
322-
Utils.decorateArg(fnDef.return, classDef, fnDef, fnOverrides.return || {});
301+
Utils.decorateArg(fnDef.return, typeDef, fnDef, fnOverrides.return || {}, enums);
323302
}
324303

325304
_(collisionMappings).forEach(function(newName, collidingName) {

0 commit comments

Comments
 (0)
Back | FazBrowse Home | New Git URL