初始化

康凯

2022-05-20 aa4c235a8ca67ea8b731f90c951a465e92c0a865

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
if (typeof Promise === 'undefined') {
   throw new ReferenceError("Promise wrappers must be enabled to use the promise API");
}
 
function isAsyncCall (fn) {
   return /^[^)]+then\s*\)/.test(fn) || /\._run\(/.test(fn);
}
 
module.exports = function (baseDir) {
 
   var Git = require('./src/git');
   var gitFactory = require('./src');
   var git;
 
 
   var chain = Promise.resolve();
 
   try {
      git = gitFactory(baseDir);
   }
   catch (e) {
      chain = Promise.reject(e);
   }
 
   return Object.keys(Git.prototype).reduce(function (promiseApi, fn) {
      if (/^_|then/.test(fn)) {
         return promiseApi;
      }
 
      if (isAsyncCall(Git.prototype[fn])) {
         promiseApi[fn] = git ? asyncWrapper(fn, git) : function () {
            return chain;
         };
      }
 
      else {
         promiseApi[fn] = git ? syncWrapper(fn, git, promiseApi) : function () {
            return promiseApi;
         };
      }
 
      return promiseApi;
 
   }, {});
 
   function asyncWrapper (fn, git) {
      return function () {
         var args = [].slice.call(arguments);
 
         if (typeof args[args.length] === 'function') {
            throw new TypeError(
               "Promise interface requires that handlers are not supplied inline, " +
               "trailing function not allowed in call to " + fn);
         }
 
         return chain.then(function () {
            return new Promise(function (resolve, reject) {
               args.push(function (err, result) {
                  if (err) {
                     return reject(toError(err));
                  }
 
                  resolve(result);
               });
 
               git[fn].apply(git, args);
            });
         });
      };
   }
 
   function syncWrapper (fn, git, api) {
      return function () {
         git[fn].apply(git, arguments);
 
         return api;
      };
   }
 
};
 
function toError (error) {
 
   if (error instanceof Error) {
      return error;
   }
 
   if (typeof error === 'string') {
      return new Error(error);
   }
 
   return Object.create(new Error(error), {
      git: { value: error },
   });
}