Plato on Github

lib/cmds/issue.js

Maintainability

68.31

Lines of code

447

Created with Raphaël 2.1.002550751002015-9-222015-9-192015-9-172015-8-282015-6-222015-6-222015-6-102015-5-202015-4-72015-4-6

2015-9-28
Maintainability: 68.31

Created with Raphaël 2.1.001252503755002015-9-222015-9-192015-9-172015-8-282015-6-222015-6-222015-6-102015-5-202015-4-72015-4-6

2015-9-28
Lines of Code: 447

Difficulty

43.24

Estimated Errors

4.30

Function weight

By Complexity

Created with Raphaël 2.1.0<anonymous>.run9

By SLOC

Created with Raphaël 2.1.0<anonymous>.run105
1
/*
2
 * Copyright 2013-2015, All Rights Reserved.
3
 *
4
 * Code licensed under the BSD License:
5
 * https://github.com/node-gh/gh/blob/master/LICENSE.md
6
 *
7
 * @author Zeno Rocha <zno.rocha@gmail.com>
8
 * @author Eduardo Lundgren <edu@rdo.io>
9
 */
10
 
11
'use strict';
12
 
13
// -- Requires -------------------------------------------------------------------------------------
14
 
15
var async = require('async'),
16
    base = require('../base'),
17
    hooks = require('../hooks'),
18
    logger = require('../logger'),
19
    openUrl = require('open'),
20
    config = base.getConfig();
21
 
22
// -- Constructor ----------------------------------------------------------------------------------
23
 
24
function Issue(options) {
25
    this.options = options;
26
 
27
    if (!options.repo && !options.all) {
28
        logger.error('You must specify a Git repository with a GitHub remote to run this command');
29
    }
30
}
31
 
32
// -- Constants ------------------------------------------------------------------------------------
33
 
34
Issue.DETAILS = {
35
    alias: 'is',
36
    description: 'Provides a set of util commands to work with Issues.',
37
    iterative: 'number',
38
    commands: [
39
        'browser',
40
        'close',
41
        'comment',
42
        'list',
43
        'new',
44
        'open'
45
    ],
46
    options: {
47
        'all': Boolean,
48
        'assignee': String,
49
        'browser': Boolean,
50
        'close': Boolean,
51
        'comment': String,
52
        'detailed': Boolean,
53
        'label': String,
54
        'list': Boolean,
55
        'message': String,
56
        'milestone': [Number, String],
57
        'no-milestone': Boolean,
58
        'new': Boolean,
59
        'number': [String, Array],
60
        'open': Boolean,
61
        'remote': String,
62
        'repo': String,
63
        'state': ['open', 'closed'],
64
        'title': String,
65
        'user': String
66
    },
67
    shorthands: {
68
        'a': ['--all'],
69
        'A': ['--assignee'],
70
        'B': ['--browser'],
71
        'C': ['--close'],
72
        'c': ['--comment'],
73
        'd': ['--detailed'],
74
        'L': ['--label'],
75
        'l': ['--list'],
76
        'm': ['--message'],
77
        'M': ['--milestone'],
78
        'N': ['--new'],
79
        'n': ['--number'],
80
        'o': ['--open'],
81
        'r': ['--repo'],
82
        'S': ['--state'],
83
        't': ['--title'],
84
        'u': ['--user']
85
    },
86
    payload: function (payload, options) {
87
        if (payload[0]) {
88
            if (/^\d+$/.test(payload[0])) {
89
                options.browser = true;
90
                options.number = payload[0];
91
                return;
92
            }
93
 
94
            options.new = true;
95
            options.title = options.title || payload[0];
96
            options.message = options.message || payload[1];
97
        }
98
        else {
99
            options.list = true;
100
        }
101
    }
102
};
103
 
104
Issue.STATE_CLOSED = 'closed';
105
Issue.STATE_OPEN = 'open';
106
 
107
// -- Commands -------------------------------------------------------------------------------------
108
 
109
Issue.prototype.run = function () {
110
    var instance = this,
111
        options = instance.options;
112
 
113
    options.state = options.state || Issue.STATE_OPEN;
114
 
115
    if (options.browser) {
116
        instance.browser(options.user, options.repo, options.number);
117
    }
118
 
119
    if (options.close) {
120
        hooks.invoke('issue.close', instance, function (afterHooksCallback) {
121
            options.state = Issue.STATE_CLOSED;
122
 
123
            logger.log('Closing issue ' + logger.colors.green('#' + options.number) +
124
                ' on ' + logger.colors.green(options.user + '/' + options.repo));
125
 
126
            instance.close(function (err, issue) {
127
                if (err) {
128
                    logger.error('Can\'t close issue.');
129
                    return;
130
                }
131
 
132
                logger.log(issue.html_url);
133
                afterHooksCallback();
134
            });
135
        });
136
    }
137
 
138
    if (options.comment) {
139
        logger.log('Adding comment on issue ' + logger.colors.green('#' + options.number));
140
 
141
        instance.comment(function (err, issue) {
142
            if (err) {
143
                logger.error('Can\'t add comment.');
144
                return;
145
            }
146
 
147
            logger.log(issue.html_url);
148
        });
149
    }
150
 
151
    if (options.list) {
152
        if (options.all) {
153
            logger.log('Listing ' + logger.colors.green(options.state) + ' issues for ' +
154
                logger.colors.green(options.user));
155
 
156
            instance.listFromAllRepositories(function (err) {
157
                if (err) {
158
                    logger.error('Can\'t list issues for ' + options.user + '.');
159
                    return;
160
                }
161
            });
162
        }
163
        else {
164
            logger.log('Listing ' + logger.colors.green(options.state) +
165
                ' issues on ' + logger.colors.green(options.user + '/' + options.repo));
166
 
167
            instance.list(options.user, options.repo, function (err) {
168
                if (err) {
169
                    logger.error('Can\'t list issues on ' + options.user + '/' + options.repo);
170
                    return;
171
                }
172
            });
173
        }
174
    }
175
 
176
    if (options.new) {
177
        hooks.invoke('issue.new', instance, function (afterHooksCallback) {
178
            logger.log('Creating a new issue on ' + logger.colors.green(options.user + '/' + options.repo));
179
 
180
            instance.new(function (err, issue) {
181
                if (err) {
182
                    logger.error('Can\'t create new issue.');
183
                    return;
184
                }
185
 
186
                if (issue) {
187
                    options.number = issue.number;
188
                }
189
 
190
                logger.log(issue.html_url);
191
                afterHooksCallback();
192
            });
193
        });
194
    }
195
 
196
    if (options.open) {
197
        hooks.invoke('issue.open', instance, function (afterHooksCallback) {
198
            logger.log('Opening issue ' + logger.colors.green('#' + options.number) +
199
                ' on ' + logger.colors.green(options.user + '/' + options.repo));
200
 
201
            instance.open(function (err, issue) {
202
                if (err) {
203
                    logger.error('Can\'t open issue.');
204
                    return;
205
                }
206
 
207
                logger.log(issue.html_url);
208
                afterHooksCallback();
209
            });
210
        });
211
    }
212
 
213
};
214
 
215
Issue.prototype.browser = function (user, repo, number) {
216
    if (!number) {
217
        number = '';
218
    }
219
 
220
    openUrl('https://github.com/' + user + '/' + repo + '/issues/' + number);
221
};
222
 
223
Issue.prototype.close = function (opt_callback) {
224
    var instance = this;
225
 
226
    instance.getIssue_(function (err, issue) {
227
        if (err) {
228
            opt_callback && opt_callback(err);
229
        }
230
        else {
231
            instance.editIssue_(issue.title, Issue.STATE_CLOSED, opt_callback);
232
        }
233
    });
234
};
235
 
236
Issue.prototype.comment = function (opt_callback) {
237
    var instance = this,
238
        options = instance.options,
239
        body,
240
        payload;
241
 
242
    body = logger.applyReplacements(options.comment, config.replace) + config.signature;
243
 
244
    payload = {
245
        body: body,
246
        number: options.number,
247
        repo: options.repo,
248
        user: options.user
249
    };
250
 
251
    base.github.issues.createComment(payload, opt_callback);
252
};
253
 
254
Issue.prototype.editIssue_ = function (title, state, opt_callback) {
255
    var instance = this,
256
        options = instance.options,
257
        payload;
258
 
259
    options.label = options.label || [];
260
 
261
    payload = {
262
        labels: options.label,
263
        number: options.number,
264
        assignee: options.assignee,
265
        milestone: options.milestone,
266
        repo: options.repo,
267
        state: state,
268
        title: title,
269
        user: options.user
270
    };
271
 
272
    base.github.issues.edit(payload, opt_callback);
273
};
274
 
275
Issue.prototype.getIssue_ = function (opt_callback) {
276
    var instance = this,
277
        options = instance.options,
278
        payload;
279
 
280
    payload = {
281
        number: options.number,
282
        repo: options.repo,
283
        user: options.user
284
    };
285
 
286
    base.github.issues.getRepoIssue(payload, opt_callback);
287
};
288
 
289
Issue.prototype.list = function (user, repo, opt_callback) {
290
    var instance = this,
291
        options = instance.options,
292
        operations = [],
293
        payload;
294
 
295
    options.label = options.label || '';
296
 
297
    payload = {
298
        labels: options.label,
299
        repo: repo,
300
        state: options.state,
301
        user: user
302
    };
303
 
304
    if (options['no-milestone']) {
305
        payload.milestone = 'none';
306
    } else if (options.milestone) {
307
        payload.milestone = options.milestone;
308
    }
309
 
310
    if (options.milestone) {
311
        operations.push(function (callback) {
312
            base.github.issues.getAllMilestones({
313
                repo: repo,
314
                user: user
315
            }, function (err, results) {
316
                if (err) {
317
                    logger.warn(err.message);
318
                }
319
 
320
                results.some(function (milestone) {
321
                    if (options.milestone === milestone.title) {
322
                        logger.debug('Milestone ' + milestone.title + ' number: ' + milestone.number);
323
                        payload.milestone = milestone.number;
324
                        return true;
325
                    }
326
                });
327
 
328
                callback();
329
            });
330
        });
331
    }
332
 
333
    if (options.assignee) {
334
        payload.assignee = options.assignee;
335
    }
336
 
337
    operations.push(function (callback) {
338
        base.github.issues.repoIssues(payload, callback);
339
    });
340
 
341
    async.series(operations, function (err, results) {
342
        var issues = [];
343
 
344
        if (err && !options.all) {
345
            logger.error(logger.getErrorMessage(err));
346
        }
347
 
348
 
349
        results.forEach(function (result) {
350
            if (result) {
351
                issues = issues.concat(result);
352
            }
353
        });
354
 
355
        issues.sort(function (a, b) {
356
            return a.number > b.number ? -1 : 1;
357
        });
358
 
359
        if (issues && issues.length > 0) {
360
            issues.forEach(function (issue) {
361
                var labels = issue.label || [];
362
 
363
                logger.log(logger.colors.green('#' + issue.number) + ' ' + issue.title + ' ' +
364
                    logger.colors.magenta('@' + issue.user.login + ' (' + logger.getDuration(issues.created_at) + ')'));
365
 
366
                if (options.detailed) {
367
                    if (issue.body) {
368
                        logger.log(issue.body);
369
                    }
370
 
371
                    labels.forEach(function (label) {
372
                        labels.push(label.name);
373
                    });
374
 
375
                    if (labels.length > 0) {
376
                        logger.log(logger.colors.green('label: ') + labels.join(', '));
377
                    }
378
 
379
                    if (issue.milestone) {
380
                        logger.log(logger.colors.green('milestone: ') +
381
                            issue.milestone.title + ' - ' + issue.milestone.number);
382
                    }
383
 
384
                    logger.log(logger.colors.blue(issue.html_url));
385
                }
386
            });
387
 
388
            opt_callback && opt_callback(err);
389
        }
390
    });
391
};
392
 
393
Issue.prototype.listFromAllRepositories = function (opt_callback) {
394
    var instance = this,
395
        options = instance.options,
396
        payload;
397
 
398
    payload = {
399
        type: 'all',
400
        user: options.user
401
    };
402
 
403
    base.github.repos.getAll(payload, function (err, repositories) {
404
        if (err) {
405
            opt_callback && opt_callback(err);
406
        }
407
        else {
408
            repositories.forEach(function (repository) {
409
                instance.list(repository.owner.login, repository.name, opt_callback);
410
            });
411
        }
412
    });
413
};
414
 
415
Issue.prototype.new = function (opt_callback) {
416
    var instance = this,
417
        options = instance.options,
418
        body,
419
        payload;
420
 
421
    if (options.message) {
422
        body = logger.applyReplacements(options.message, config.replace);
423
    }
424
 
425
    if (options.label) {
426
        options.label = options.label.split(',');
427
    }
428
    else {
429
        options.label = [];
430
    }
431
 
432
    payload = {
433
        assignee: options.assignee,
434
        body: body,
435
        repo: options.repo,
436
        title: options.title,
437
        user: options.user,
438
        labels: options.label
439
    };
440
 
441
    base.github.issues.create(payload, opt_callback);
442
};
443
 
444
Issue.prototype.open = function (opt_callback) {
445
    var instance = this;
446
 
447
    instance.getIssue_(function (err, issue) {
448
        if (err) {
449
            opt_callback && opt_callback(err);
450
        }
451
        else {
452
            instance.editIssue_(issue.title, Issue.STATE_OPEN, opt_callback);
453
        }
454
    });
455
};
456
 
457
exports.Impl = Issue;