From 39c49984c874a17667b0a4ea17a87f30201331fa Mon Sep 17 00:00:00 2001 From: Randal Pinto Date: Wed, 3 Aug 2016 12:20:57 +0100 Subject: [PATCH 01/11] Replace axios with request-http-cache. --- gulpfile.babel.js | 11 ++++++----- lib/Requestable.js | 46 ++++++++++++++++++++++++++++++++++++++++++---- package.json | 3 ++- 3 files changed, 50 insertions(+), 10 deletions(-) diff --git a/gulpfile.babel.js b/gulpfile.babel.js index c3d669f5..7cc83f23 100644 --- a/gulpfile.babel.js +++ b/gulpfile.babel.js @@ -29,10 +29,10 @@ gulp.task('clean', function() { }); gulp.task('build', [ - 'build:bundled:min', - 'build:external:min', - 'build:bundled:debug', - 'build:external:debug', +// 'build:bundled:min', +// 'build:external:min', +// 'build:bundled:debug', +// 'build:external:debug', 'build:components' ]); @@ -46,7 +46,8 @@ const externalConfig = { entries: 'lib/GitHub.js', standalone: 'GitHub', external: [ - 'axios', + 'request-extensible', + 'request-http-cache', 'js-base64', 'es6-promise', 'debug', diff --git a/lib/Requestable.js b/lib/Requestable.js index 95c23bbd..a984876e 100644 --- a/lib/Requestable.js +++ b/lib/Requestable.js @@ -5,11 +5,20 @@ * Github.js is freely distributable. */ -import axios from 'axios'; +import requestExt from 'request-extensible'; +import RequestHttpCache from 'request-http-cache'; import debug from 'debug'; import {Base64} from 'js-base64'; import {polyfill} from 'es6-promise'; +const httpRequestCache = new RequestHttpCache({ + max: 256*1024*1024 // Maximum cache size (256mb) +}); + +const request = requestExt({ + extensions: [ httpRequestCache.extension ] +}); + const log = debug('github:request'); if (typeof Promise === 'undefined') { @@ -152,9 +161,14 @@ class Requestable { */ _request(method, path, data, cb, raw) { const url = this.__getURL(path); - const headers = this.__getRequestHeaders(raw); - let queryParams = {}; + let headers = this.__getRequestHeaders(raw); + // Failsafe check for directly making request from NodeJS + if(!headers['User-Agent']) { + headers['User-Agent'] = 'request'; + } + + let queryParams = {}; const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method); if (shouldUseDataAsParams) { queryParams = data; @@ -171,7 +185,31 @@ class Requestable { }; log(`${config.method} to ${config.url}`); - const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path)); + + const requestPromise = new Promise((resolve, reject) => { + request(config, function(err, response, body) { + let ret = { + status: response.statusCode, + statusText: response.statusMessage, + headers: response.headers, + config: config + } + if(err === null && response.statusCode >= 200 && response.statusCode < 300) { + if(raw) { + ret.data = body; + } + else { + ret.data = JSON.parse(body); + } + resolve(ret); + } + else { + ret.data = body; + callbackErrorOrThrow(cb, path)(ret); + } + }); + }); + // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path)); if (cb) { requestPromise.then((response) => { diff --git a/package.json b/package.json index 15d451a0..d113ad20 100644 --- a/package.json +++ b/package.json @@ -45,10 +45,11 @@ "lib/*" ], "dependencies": { - "axios": "^0.10.0", "debug": "^2.2.0", "es6-promise": "^3.0.2", "js-base64": "^2.1.9", + "request-extensible": "^0.1.1", + "request-http-cache": "^1.0.1", "utf8": "^2.1.1" }, "devDependencies": { From 48572b6939978d6142adf080a730a02833f6303b Mon Sep 17 00:00:00 2001 From: Randal Pinto Date: Wed, 3 Aug 2016 12:43:26 +0100 Subject: [PATCH 02/11] Uploading dist folder so npm can pull directly from git. --- .gitignore | 1 - dist/components/Gist.js | 176 ++++++++++ dist/components/Gist.js.map | 1 + dist/components/GitHub.js | 151 ++++++++ dist/components/GitHub.js.map | 1 + dist/components/Issue.js | 187 ++++++++++ dist/components/Issue.js.map | 1 + dist/components/Markdown.js | 112 ++++++ dist/components/Markdown.js.map | 1 + dist/components/Organization.js | 139 ++++++++ dist/components/Organization.js.map | 1 + dist/components/RateLimit.js | 108 ++++++ dist/components/RateLimit.js.map | 1 + dist/components/Repository.js | 519 ++++++++++++++++++++++++++++ dist/components/Repository.js.map | 1 + dist/components/Requestable.js | 383 ++++++++++++++++++++ dist/components/Requestable.js.map | 1 + dist/components/Search.js | 164 +++++++++ dist/components/Search.js.map | 1 + dist/components/Team.js | 174 ++++++++++ dist/components/Team.js.map | 1 + dist/components/User.js | 197 +++++++++++ dist/components/User.js.map | 1 + package.json | 2 +- 24 files changed, 2322 insertions(+), 2 deletions(-) create mode 100644 dist/components/Gist.js create mode 100644 dist/components/Gist.js.map create mode 100644 dist/components/GitHub.js create mode 100644 dist/components/GitHub.js.map create mode 100644 dist/components/Issue.js create mode 100644 dist/components/Issue.js.map create mode 100644 dist/components/Markdown.js create mode 100644 dist/components/Markdown.js.map create mode 100644 dist/components/Organization.js create mode 100644 dist/components/Organization.js.map create mode 100644 dist/components/RateLimit.js create mode 100644 dist/components/RateLimit.js.map create mode 100644 dist/components/Repository.js create mode 100644 dist/components/Repository.js.map create mode 100644 dist/components/Requestable.js create mode 100644 dist/components/Requestable.js.map create mode 100644 dist/components/Search.js create mode 100644 dist/components/Search.js.map create mode 100644 dist/components/Team.js create mode 100644 dist/components/Team.js.map create mode 100644 dist/components/User.js create mode 100644 dist/components/User.js.map diff --git a/.gitignore b/.gitignore index 6d462a19..9bcb7b6c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,6 @@ .sass-cache/ _site/ docs/ -dist/ coverage/ node_modules/ diff --git a/dist/components/Gist.js b/dist/components/Gist.js new file mode 100644 index 00000000..6b9bdc8a --- /dev/null +++ b/dist/components/Gist.js @@ -0,0 +1,176 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable); + global.Gist = mod.exports; + } +})(this, function (module, _Requestable2) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var Gist = function (_Requestable) { + _inherits(Gist, _Requestable); + + /** + * Create a Gist. + * @param {string} id - the id of the gist (not required when creating a gist) + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Gist(id, auth, apiBase) { + _classCallCheck(this, Gist); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Gist).call(this, auth, apiBase)); + + _this.__id = id; + return _this; + } + + /** + * Fetch a gist. + * @see https://developer.github.com/v3/gists/#get-a-single-gist + * @param {Requestable.callback} [cb] - will receive the gist + * @return {Promise} - the Promise for the http request + */ + + + _createClass(Gist, [{ + key: 'read', + value: function read(cb) { + return this._request('GET', '/gists/' + this.__id, null, cb); + } + }, { + key: 'create', + value: function create(gist, cb) { + var _this2 = this; + + return this._request('POST', '/gists', gist, cb).then(function (response) { + _this2.__id = response.data.id; + return response; + }); + } + }, { + key: 'delete', + value: function _delete(cb) { + return this._request('DELETE', '/gists/' + this.__id, null, cb); + } + }, { + key: 'fork', + value: function fork(cb) { + return this._request('POST', '/gists/' + this.__id + '/forks', null, cb); + } + }, { + key: 'update', + value: function update(gist, cb) { + return this._request('PATCH', '/gists/' + this.__id, gist, cb); + } + }, { + key: 'star', + value: function star(cb) { + return this._request('PUT', '/gists/' + this.__id + '/star', null, cb); + } + }, { + key: 'unstar', + value: function unstar(cb) { + return this._request('DELETE', '/gists/' + this.__id + '/star', null, cb); + } + }, { + key: 'isStarred', + value: function isStarred(cb) { + return this._request204or404('/gists/' + this.__id + '/star', null, cb); + } + }, { + key: 'listComments', + value: function listComments(cb) { + return this._requestAllPages('/gists/' + this.__id + '/comments', null, cb); + } + }, { + key: 'getComment', + value: function getComment(comment, cb) { + return this._request('GET', '/gists/' + this.__id + '/comments/' + comment, null, cb); + } + }, { + key: 'createComment', + value: function createComment(comment, cb) { + return this._request('POST', '/gists/' + this.__id + '/comments', { body: comment }, cb); + } + }, { + key: 'editComment', + value: function editComment(comment, body, cb) { + return this._request('PATCH', '/gists/' + this.__id + '/comments/' + comment, { body: body }, cb); + } + }, { + key: 'deleteComment', + value: function deleteComment(comment, cb) { + return this._request('DELETE', '/gists/' + this.__id + '/comments/' + comment, null, cb); + } + }]); + + return Gist; + }(_Requestable3.default); + + module.exports = Gist; +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Gist.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAYM,I;;;AACH;;;;;;AAMA,kBAAY,EAAZ,EAAgB,IAAhB,EAAsB,OAAtB,EAA+B;AAAA;;AAAA,0FACtB,IADsB,EAChB,OADgB;;AAE5B,YAAK,IAAL,GAAY,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;2BAMK,E,EAAI;AACN,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,EAA4C,IAA5C,EAAkD,EAAlD,CAAP;AACF;;;6BASM,I,EAAM,E,EAAI;AAAA;;AACd,eAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,QAAtB,EAAgC,IAAhC,EAAsC,EAAtC,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,iBAAK,IAAL,GAAY,SAAS,IAAT,CAAc,EAA1B;AACA,iBAAO,QAAP;AACF,SAJG,CAAP;AAKF;;;8BAQM,E,EAAI;AACR,eAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,EAA+C,IAA/C,EAAqD,EAArD,CAAP;AACF;;;2BAQI,E,EAAI;AACN,eAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,aAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;;6BASM,I,EAAM,E,EAAI;AACd,eAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;;2BAQI,E,EAAI;AACN,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,YAAiD,IAAjD,EAAuD,EAAvD,CAAP;AACF;;;6BAQM,E,EAAI;AACR,eAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,YAAoD,IAApD,EAA0D,EAA1D,CAAP;AACF;;;gCAQS,E,EAAI;AACX,eAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,YAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;;mCAQY,E,EAAI;AACd,eAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,gBAAsD,IAAtD,EAA4D,EAA5D,CAAP;AACF;;;iCASU,O,EAAS,E,EAAI;AACrB,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,kBAAqD,OAArD,EAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;;oCASa,O,EAAS,E,EAAI;AACxB,eAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,gBAAsD,EAAC,MAAM,OAAP,EAAtD,EAAuE,EAAvE,CAAP;AACF;;;kCAUW,O,EAAS,I,EAAM,E,EAAI;AAC5B,eAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,kBAAuD,OAAvD,EAAkE,EAAC,MAAM,IAAP,EAAlE,EAAgF,EAAhF,CAAP;AACF;;;oCASa,O,EAAS,E,EAAI;AACxB,eAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,kBAAwD,OAAxD,EAAmE,IAAnE,EAAyE,EAAzE,CAAP;AACF;;;;;;AAGJ,SAAO,OAAP,GAAiB,IAAjB","file":"Gist.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n"]} +//# sourceMappingURL=Gist.js.map diff --git a/dist/components/Gist.js.map b/dist/components/Gist.js.map new file mode 100644 index 00000000..17233eae --- /dev/null +++ b/dist/components/Gist.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Gist.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n /**\n * Create a Gist.\n * @param {string} id - the id of the gist (not required when creating a gist)\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase);\n this.__id = id;\n }\n\n /**\n * Fetch a gist.\n * @see https://developer.github.com/v3/gists/#get-a-single-gist\n * @param {Requestable.callback} [cb] - will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n read(cb) {\n return this._request('GET', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Create a new gist.\n * @see https://developer.github.com/v3/gists/#create-a-gist\n * @param {Object} gist - the data for the new gist\n * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n * @return {Promise} - the Promise for the http request\n */\n create(gist, cb) {\n return this._request('POST', '/gists', gist, cb)\n .then((response) => {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n"],"file":"Gist.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/GitHub.js b/dist/components/GitHub.js new file mode 100644 index 00000000..8d6bc2f5 --- /dev/null +++ b/dist/components/GitHub.js @@ -0,0 +1,151 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Gist', './User', './Issue', './Search', './RateLimit', './Repository', './Organization', './Team', './Markdown'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Gist'), require('./User'), require('./Issue'), require('./Search'), require('./RateLimit'), require('./Repository'), require('./Organization'), require('./Team'), require('./Markdown')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Gist, global.User, global.Issue, global.Search, global.RateLimit, global.Repository, global.Organization, global.Team, global.Markdown); + global.GitHub = mod.exports; + } +})(this, function (module, _Gist, _User, _Issue, _Search, _RateLimit, _Repository, _Organization, _Team, _Markdown) { + 'use strict'; + + var _Gist2 = _interopRequireDefault(_Gist); + + var _User2 = _interopRequireDefault(_User); + + var _Issue2 = _interopRequireDefault(_Issue); + + var _Search2 = _interopRequireDefault(_Search); + + var _RateLimit2 = _interopRequireDefault(_RateLimit); + + var _Repository2 = _interopRequireDefault(_Repository); + + var _Organization2 = _interopRequireDefault(_Organization); + + var _Team2 = _interopRequireDefault(_Team); + + var _Markdown2 = _interopRequireDefault(_Markdown); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + var GitHub = function () { + /** + * Create a new GitHub. + * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is + * not provided requests will be made unauthenticated + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function GitHub(auth) { + var apiBase = arguments.length <= 1 || arguments[1] === undefined ? 'https://api.github.com' : arguments[1]; + + _classCallCheck(this, GitHub); + + this.__apiBase = apiBase; + this.__auth = auth || {}; + } + + /** + * Create a new Gist wrapper + * @param {number} [id] - the id for the gist, leave undefined when creating a new gist + * @return {Gist} + */ + + + _createClass(GitHub, [{ + key: 'getGist', + value: function getGist(id) { + return new _Gist2.default(id, this.__auth, this.__apiBase); + } + }, { + key: 'getUser', + value: function getUser(user) { + return new _User2.default(user, this.__auth, this.__apiBase); + } + }, { + key: 'getOrganization', + value: function getOrganization(organization) { + return new _Organization2.default(organization, this.__auth, this.__apiBase); + } + }, { + key: 'getTeam', + value: function getTeam(teamId) { + return new _Team2.default(teamId, this.__auth, this.__apiBase); + } + }, { + key: 'getRepo', + value: function getRepo(user, repo) { + return new _Repository2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + }, { + key: 'getIssues', + value: function getIssues(user, repo) { + return new _Issue2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + }, { + key: 'search', + value: function search(query) { + return new _Search2.default(query, this.__auth, this.__apiBase); + } + }, { + key: 'getRateLimit', + value: function getRateLimit() { + return new _RateLimit2.default(this.__auth, this.__apiBase); + } + }, { + key: 'getMarkdown', + value: function getMarkdown() { + return new _Markdown2.default(this.__auth, this.__apiBase); + } + }, { + key: '_getFullName', + value: function _getFullName(user, repo) { + var fullname = user; + + if (repo) { + fullname = user + '/' + repo; + } + + return fullname; + } + }]); + + return GitHub; + }(); + + module.exports = GitHub; +}); +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=GitHub.js.map diff --git a/dist/components/GitHub.js.map b/dist/components/GitHub.js.map new file mode 100644 index 00000000..3b6254c6 --- /dev/null +++ b/dist/components/GitHub.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["GitHub.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n"],"file":"GitHub.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Issue.js b/dist/components/Issue.js new file mode 100644 index 00000000..7db01b7d --- /dev/null +++ b/dist/components/Issue.js @@ -0,0 +1,187 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable); + global.Issue = mod.exports; + } +})(this, function (module, _Requestable2) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var Issue = function (_Requestable) { + _inherits(Issue, _Requestable); + + /** + * Create a new Issue + * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Issue(repository, auth, apiBase) { + _classCallCheck(this, Issue); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Issue).call(this, auth, apiBase)); + + _this.__repository = repository; + return _this; + } + + /** + * Create a new issue + * @see https://developer.github.com/v3/issues/#create-an-issue + * @param {Object} issueData - the issue to create + * @param {Requestable.callback} [cb] - will receive the created issue + * @return {Promise} - the promise for the http request + */ + + + _createClass(Issue, [{ + key: 'createIssue', + value: function createIssue(issueData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues', issueData, cb); + } + }, { + key: 'listIssues', + value: function listIssues(options, cb) { + return this._requestAllPages('/repos/' + this.__repository + '/issues', options, cb); + } + }, { + key: 'listIssueEvents', + value: function listIssueEvents(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/events', null, cb); + } + }, { + key: 'listIssueComments', + value: function listIssueComments(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/comments', null, cb); + } + }, { + key: 'getIssueComment', + value: function getIssueComment(id, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + }, { + key: 'createIssueComment', + value: function createIssueComment(issue, comment, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues/' + issue + '/comments', { body: comment }, cb); + } + }, { + key: 'editIssueComment', + value: function editIssueComment(id, comment, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/comments/' + id, { body: comment }, cb); + } + }, { + key: 'deleteIssueComment', + value: function deleteIssueComment(id, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + }, { + key: 'editIssue', + value: function editIssue(issue, issueData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/' + issue, issueData, cb); + } + }, { + key: 'getIssue', + value: function getIssue(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue, null, cb); + } + }, { + key: 'listMilestones', + value: function listMilestones(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones', options, cb); + } + }, { + key: 'getMilestone', + value: function getMilestone(milestone, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + }, { + key: 'createMilestone', + value: function createMilestone(milestoneData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/milestones', milestoneData, cb); + } + }, { + key: 'editMilestone', + value: function editMilestone(milestone, milestoneData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/milestones/' + milestone, milestoneData, cb); + } + }, { + key: 'deleteMilestone', + value: function deleteMilestone(milestone, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + }, { + key: 'createLabel', + value: function createLabel(labelData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/labels', labelData, cb); + } + }]); + + return Issue; + }(_Requestable3.default); + + module.exports = Issue; +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Issue.js"],"names":[],"mappings":"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","file":"Issue.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n}\n\nmodule.exports = Issue;\n"]} +//# sourceMappingURL=Issue.js.map diff --git a/dist/components/Issue.js.map b/dist/components/Issue.js.map new file mode 100644 index 00000000..64bc1b9d --- /dev/null +++ b/dist/components/Issue.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Issue.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n}\n\nmodule.exports = Issue;\n"],"file":"Issue.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Markdown.js b/dist/components/Markdown.js new file mode 100644 index 00000000..fc6fa3cc --- /dev/null +++ b/dist/components/Markdown.js @@ -0,0 +1,112 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable); + global.Markdown = mod.exports; + } +})(this, function (module, _Requestable2) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var Markdown = function (_Requestable) { + _inherits(Markdown, _Requestable); + + /** + * construct a RateLimit + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function Markdown(auth, apiBase) { + _classCallCheck(this, Markdown); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(Markdown).call(this, auth, apiBase)); + } + + /** + * Render html from Markdown text. + * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document + * @param {Object} options - conversion options + * @param {string} [options.text] - the markdown text to convert + * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm` + * @param {string} [options.context] - repository name if mode is gfm + * @param {Requestable.callback} [cb] - will receive the converted html + * @return {Promise} - the promise for the http request + */ + + + _createClass(Markdown, [{ + key: 'render', + value: function render(options, cb) { + return this._request('POST', '/markdown', options, cb); + } + }]); + + return Markdown; + }(_Requestable3.default); + + module.exports = Markdown; +}); +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=Markdown.js.map diff --git a/dist/components/Markdown.js.map b/dist/components/Markdown.js.map new file mode 100644 index 00000000..dd128433 --- /dev/null +++ b/dist/components/Markdown.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Markdown.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass Markdown extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n"],"file":"Markdown.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Organization.js b/dist/components/Organization.js new file mode 100644 index 00000000..fc05a4c3 --- /dev/null +++ b/dist/components/Organization.js @@ -0,0 +1,139 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable); + global.Organization = mod.exports; + } +})(this, function (module, _Requestable2) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var Organization = function (_Requestable) { + _inherits(Organization, _Requestable); + + /** + * Create a new Organization + * @param {string} organization - the name of the organization + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Organization(organization, auth, apiBase) { + _classCallCheck(this, Organization); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Organization).call(this, auth, apiBase)); + + _this.__name = organization; + return _this; + } + + /** + * Create a repository in an organization + * @see https://developer.github.com/v3/repos/#create + * @param {Object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the created repository + * @return {Promise} - the promise for the http request + */ + + + _createClass(Organization, [{ + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/repos', options, cb); + } + }, { + key: 'getRepos', + value: function getRepos(cb) { + var requestOptions = this._getOptionsWithDefaults({ direction: 'desc' }); + + return this._requestAllPages('/orgs/' + this.__name + '/repos', requestOptions, cb); + } + }, { + key: 'isMember', + value: function isMember(username, cb) { + return this._request204or404('/orgs/' + this.__name + '/members/' + username, null, cb); + } + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + return this._request('GET', '/orgs/' + this.__name + '/members', options, cb); + } + }, { + key: 'getTeams', + value: function getTeams(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/teams', undefined, cb); + } + }, { + key: 'createTeam', + value: function createTeam(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/teams', options, cb); + } + }]); + + return Organization; + }(_Requestable3.default); + + module.exports = Organization; +}); +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=Organization.js.map diff --git a/dist/components/Organization.js.map b/dist/components/Organization.js.map new file mode 100644 index 00000000..67f2838d --- /dev/null +++ b/dist/components/Organization.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Organization.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n"],"file":"Organization.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/RateLimit.js b/dist/components/RateLimit.js new file mode 100644 index 00000000..87ed0ccf --- /dev/null +++ b/dist/components/RateLimit.js @@ -0,0 +1,108 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable); + global.RateLimit = mod.exports; + } +})(this, function (module, _Requestable2) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var RateLimit = function (_Requestable) { + _inherits(RateLimit, _Requestable); + + /** + * construct a RateLimit + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function RateLimit(auth, apiBase) { + _classCallCheck(this, RateLimit); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(RateLimit).call(this, auth, apiBase)); + } + + /** + * Query the current rate limit + * @see https://developer.github.com/v3/rate_limit/ + * @param {Requestable.callback} [cb] - will receive the rate-limit data + * @return {Promise} - the promise for the http request + */ + + + _createClass(RateLimit, [{ + key: 'getRateLimit', + value: function getRateLimit(cb) { + return this._request('GET', '/rate_limit', null, cb); + } + }]); + + return RateLimit; + }(_Requestable3.default); + + module.exports = RateLimit; +}); +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=RateLimit.js.map diff --git a/dist/components/RateLimit.js.map b/dist/components/RateLimit.js.map new file mode 100644 index 00000000..8cae1491 --- /dev/null +++ b/dist/components/RateLimit.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["RateLimit.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n"],"file":"RateLimit.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Repository.js b/dist/components/Repository.js new file mode 100644 index 00000000..512829cc --- /dev/null +++ b/dist/components/Repository.js @@ -0,0 +1,519 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable', 'utf8', 'js-base64', 'debug'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable'), require('utf8'), require('js-base64'), require('debug')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable, global.utf8, global.jsBase64, global.debug); + global.Repository = mod.exports; + } +})(this, function (module, _Requestable2, _utf, _jsBase, _debug) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + var _utf2 = _interopRequireDefault(_utf); + + var _debug2 = _interopRequireDefault(_debug); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; + }; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var log = (0, _debug2.default)('github:repository'); + + /** + * Respository encapsulates the functionality to create, query, and modify files. + */ + + var Repository = function (_Requestable) { + _inherits(Repository, _Requestable); + + /** + * Create a Repository. + * @param {string} fullname - the full name of the repository + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Repository(fullname, auth, apiBase) { + _classCallCheck(this, Repository); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Repository).call(this, auth, apiBase)); + + _this.__fullname = fullname; + _this.__currentTree = { + branch: null, + sha: null + }; + return _this; + } + + /** + * Get a reference + * @see https://developer.github.com/v3/git/refs/#get-a-reference + * @param {string} ref - the reference to get + * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref` + * @return {Promise} - the promise for the http request + */ + + + _createClass(Repository, [{ + key: 'getRef', + value: function getRef(ref, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + }, { + key: 'createRef', + value: function createRef(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/refs', options, cb); + } + }, { + key: 'deleteRef', + value: function deleteRef(ref, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + }, { + key: 'deleteRepo', + value: function deleteRepo(cb) { + return this._request('DELETE', '/repos/' + this.__fullname, null, cb); + } + }, { + key: 'listTags', + value: function listTags(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/tags', null, cb); + } + }, { + key: 'listPullRequests', + value: function listPullRequests(options, cb) { + options = options || {}; + return this._request('GET', '/repos/' + this.__fullname + '/pulls', options, cb); + } + }, { + key: 'getPullRequest', + value: function getPullRequest(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number, null, cb); + } + }, { + key: 'listPullRequestFiles', + value: function listPullRequestFiles(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number + '/files', null, cb); + } + }, { + key: 'compareBranches', + value: function compareBranches(base, head, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/compare/' + base + '...' + head, null, cb); + } + }, { + key: 'listBranches', + value: function listBranches(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); + } + }, { + key: 'getBlob', + value: function getBlob(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/blobs/' + sha, null, cb, 'raw'); + } + }, { + key: 'getCommit', + value: function getCommit(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/commits/' + sha, null, cb); + } + }, { + key: 'listCommits', + value: function listCommits(options, cb) { + options = options || {}; + + options.since = this._dateToISO(options.since); + options.until = this._dateToISO(options.until); + + return this._request('GET', '/repos/' + this.__fullname + '/commits', options, cb); + } + }, { + key: 'getSingleCommit', + value: function getSingleCommit(ref, cb) { + ref = ref || ''; + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + ref, null, cb); + } + }, { + key: 'getSha', + value: function getSha(branch, path, cb) { + branch = branch ? '?ref=' + branch : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path + branch, null, cb); + } + }, { + key: 'listStatuses', + value: function listStatuses(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + sha + '/statuses', null, cb); + } + }, { + key: 'getTree', + value: function getTree(treeSHA, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/trees/' + treeSHA, null, cb); + } + }, { + key: 'createBlob', + value: function createBlob(content, cb) { + var postBody = this._getContentObject(content); + + log('sending content', postBody); + return this._request('POST', '/repos/' + this.__fullname + '/git/blobs', postBody, cb); + } + }, { + key: '_getContentObject', + value: function _getContentObject(content) { + if (typeof content === 'string') { + log('contet is a string'); + return { + content: _utf2.default.encode(content), + encoding: 'utf-8' + }; + } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) { + log('We appear to be in Node'); + return { + content: content.toString('base64'), + encoding: 'base64' + }; + } else if (typeof Blob !== 'undefined' && content instanceof Blob) { + log('We appear to be in the browser'); + return { + content: _jsBase.Base64.encode(content), + encoding: 'base64' + }; + } else { + // eslint-disable-line + log('Not sure what this content is: ' + (typeof content === 'undefined' ? 'undefined' : _typeof(content)) + ', ' + JSON.stringify(content)); + throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)'); + } + } + }, { + key: 'updateTree', + value: function updateTree(baseTreeSHA, path, blobSHA, cb) { + var newTree = { + base_tree: baseTreeSHA, // eslint-disable-line + tree: [{ + path: path, + sha: blobSHA, + mode: '100644', + type: 'blob' + }] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', newTree, cb); + } + }, { + key: 'createTree', + value: function createTree(tree, baseSHA, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', { + tree: tree, + base_tree: baseSHA // eslint-disable-line + }, cb); + } + }, { + key: 'commit', + value: function commit(parent, tree, message, cb) { + var _this2 = this; + + var data = { + message: message, + tree: tree, + parents: [parent] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/commits', data, cb).then(function (response) { + _this2.__currentTree.sha = response.data.sha; // Update latest commit + return response; + }); + } + }, { + key: 'updateHead', + value: function updateHead(ref, commitSHA, force, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/git/refs/' + ref, { + sha: commitSHA, + force: force + }, cb); + } + }, { + key: 'getDetails', + value: function getDetails(cb) { + return this._request('GET', '/repos/' + this.__fullname, null, cb); + } + }, { + key: 'getContributors', + value: function getContributors(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/stats/contributors', null, cb); + } + }, { + key: 'getCollaborators', + value: function getCollaborators(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators', null, cb); + } + }, { + key: 'isCollaborator', + value: function isCollaborator(username, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators/' + username, null, cb); + } + }, { + key: 'getContents', + value: function getContents(ref, path, raw, cb) { + path = path ? '' + encodeURI(path) : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path, { + ref: ref + }, cb, raw); + } + }, { + key: 'getReadme', + value: function getReadme(ref, raw, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/readme', { + ref: ref + }, cb, raw); + } + }, { + key: 'fork', + value: function fork(cb) { + return this._request('POST', '/repos/' + this.__fullname + '/forks', null, cb); + } + }, { + key: 'listForks', + value: function listForks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/forks', null, cb); + } + }, { + key: 'createBranch', + value: function createBranch(oldBranch, newBranch, cb) { + var _this3 = this; + + if (typeof newBranch === 'function') { + cb = newBranch; + newBranch = oldBranch; + oldBranch = 'master'; + } + + return this.getRef('heads/' + oldBranch).then(function (response) { + var sha = response.data.object.sha; + return _this3.createRef({ + sha: sha, + ref: 'refs/heads/' + newBranch + }, cb); + }); + } + }, { + key: 'createPullRequest', + value: function createPullRequest(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/pulls', options, cb); + } + }, { + key: 'updatePullRequst', + value: function updatePullRequst(number, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/pulls/' + number, options, cb); + } + }, { + key: 'listHooks', + value: function listHooks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks', null, cb); + } + }, { + key: 'getHook', + value: function getHook(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + }, { + key: 'createHook', + value: function createHook(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/hooks', options, cb); + } + }, { + key: 'updateHook', + value: function updateHook(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/hooks/' + id, options, cb); + } + }, { + key: 'deleteHook', + value: function deleteHook(id, cb) { + return this._request('DELETE', this.__repoPath + '/hooks/' + id, null, cb); + } + }, { + key: 'deleteFile', + value: function deleteFile(branch, path, cb) { + var _this4 = this; + + return this.getSha(branch, path).then(function (response) { + var deleteCommit = { + message: 'Delete the file at \'' + path + '\'', + sha: response.data.sha, + branch: branch + }; + return _this4._request('DELETE', '/repos/' + _this4.__fullname + '/contents/' + path, deleteCommit, cb); + }); + } + }, { + key: 'move', + value: function move(branch, oldPath, newPath, cb) { + var _this5 = this; + + var oldSha = void 0; + return this.getRef('heads/' + branch).then(function (_ref) { + var object = _ref.data.object; + return _this5.getTree(object.sha + '?recursive=true'); + }).then(function (_ref2) { + var _ref2$data = _ref2.data; + var tree = _ref2$data.tree; + var sha = _ref2$data.sha; + + oldSha = sha; + var newTree = tree.map(function (ref) { + if (ref.path === oldPath) { + ref.path = newPath; + } + if (ref.type === 'tree') { + delete ref.sha; + } + return ref; + }); + return _this5.createTree(newTree); + }).then(function (_ref3) { + var tree = _ref3.data; + return _this5.commit(oldSha, tree.sha, 'Renamed \'' + oldPath + '\' to \'' + newPath + '\''); + }).then(function (_ref4) { + var commit = _ref4.data; + return _this5.updateHead('heads/' + branch, commit.sha, true, cb); + }); + } + }, { + key: 'writeFile', + value: function writeFile(branch, path, content, message, options, cb) { + var _this6 = this; + + if (typeof options === 'function') { + cb = options; + options = {}; + } + var filePath = path ? encodeURI(path) : ''; + var shouldEncode = options.encode !== false; + var commit = { + branch: branch, + message: message, + author: options.author, + committer: options.committer, + content: shouldEncode ? _jsBase.Base64.encode(content) : content + }; + + return this.getSha(branch, filePath).then(function (response) { + commit.sha = response.data.sha; + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }, function () { + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }); + } + }, { + key: 'isStarred', + value: function isStarred(cb) { + return this._request204or404('/user/starred/' + this.__fullname, null, cb); + } + }, { + key: 'star', + value: function star(cb) { + return this._request('PUT', '/user/starred/' + this.__fullname, null, cb); + } + }, { + key: 'unstar', + value: function unstar(cb) { + return this._request('DELETE', '/user/starred/' + this.__fullname, null, cb); + } + }, { + key: 'createRelease', + value: function createRelease(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/releases', options, cb); + } + }, { + key: 'updateRelease', + value: function updateRelease(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/releases/' + id, options, cb); + } + }, { + key: 'listReleases', + value: function listReleases(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases', null, cb); + } + }, { + key: 'getRelease', + value: function getRelease(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + }, { + key: 'deleteRelease', + value: function deleteRelease(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + }, { + key: 'mergePullRequest', + value: function mergePullRequest(number, options, cb) { + return this._request('PUT', '/repos/' + this.__fullname + '/pulls/' + number + '/merge', options, cb); + } + }]); + + return Repository; + }(_Requestable3.default); + + module.exports = Repository; +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Repository.js"],"names":[],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} +//# sourceMappingURL=Repository.js.map diff --git a/dist/components/Repository.js.map b/dist/components/Repository.js.map new file mode 100644 index 00000000..6acc27a7 --- /dev/null +++ b/dist/components/Repository.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Requestable.js b/dist/components/Requestable.js new file mode 100644 index 00000000..45979734 --- /dev/null +++ b/dist/components/Requestable.js @@ -0,0 +1,383 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', 'request-extensible', 'request-http-cache', 'debug', 'js-base64', 'es6-promise'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('request-extensible'), require('request-http-cache'), require('debug'), require('js-base64'), require('es6-promise')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.requestExtensible, global.requestHttpCache, global.debug, global.jsBase64, global.Promise); + global.Requestable = mod.exports; + } +})(this, function (module, _requestExtensible, _requestHttpCache, _debug, _jsBase, _es6Promise) { + 'use strict'; + + var _requestExtensible2 = _interopRequireDefault(_requestExtensible); + + var _requestHttpCache2 = _interopRequireDefault(_requestHttpCache); + + var _debug2 = _interopRequireDefault(_debug); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; + }; + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var httpRequestCache = new _requestHttpCache2.default({ + max: 256 * 1024 * 1024 // Maximum cache size (256mb) + }); + + var request = (0, _requestExtensible2.default)({ + extensions: [httpRequestCache.extension] + }); + + var log = (0, _debug2.default)('github:request'); + + if (typeof Promise === 'undefined') { + (0, _es6Promise.polyfill)(); + } + + /** + * The error structure returned when a network call fails + */ + + var ResponseError = function (_Error) { + _inherits(ResponseError, _Error); + + /** + * Construct a new ResponseError + * @param {string} message - an message to return instead of the the default error message + * @param {string} path - the requested path + * @param {Object} response - the object returned by Axios + */ + function ResponseError(message, path, response) { + _classCallCheck(this, ResponseError); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ResponseError).call(this, message)); + + _this.path = path; + _this.request = response.config; + _this.response = response; + _this.status = response.status; + return _this; + } + + return ResponseError; + }(Error); + + var Requestable = function () { + /** + * Either a username and password or an oauth token for Github + * @typedef {Object} Requestable.auth + * @prop {string} [username] - the Github username + * @prop {string} [password] - the user's password + * @prop {token} [token] - an OAuth token + */ + /** + * Initialize the http internals. + * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is + * not provided request will be made unauthenticated + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Requestable(auth, apiBase) { + _classCallCheck(this, Requestable); + + this.__apiBase = apiBase || 'https://api.github.com'; + this.__auth = { + token: auth.token, + username: auth.username, + password: auth.password + }; + + if (auth.token) { + this.__authorizationHeader = 'token ' + auth.token; + } else if (auth.username && auth.password) { + this.__authorizationHeader = 'Basic ' + _jsBase.Base64.encode(auth.username + ':' + auth.password); + } + } + + /** + * Compute the URL to use to make a request. + * @private + * @param {string} path - either a URL relative to the API base or an absolute URL + * @return {string} - the URL to use + */ + + + _createClass(Requestable, [{ + key: '__getURL', + value: function __getURL(path) { + var url = path; + + if (path.indexOf('//') === -1) { + url = this.__apiBase + path; + } + + var newCacheBuster = 'timestamp=' + new Date().getTime(); + return url.replace(/(timestamp=\d+)/, newCacheBuster); + } + }, { + key: '__getRequestHeaders', + value: function __getRequestHeaders(raw) { + var headers = { + 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json', + 'Content-Type': 'application/json;charset=UTF-8' + }; + + if (this.__authorizationHeader) { + headers.Authorization = this.__authorizationHeader; + } + + return headers; + } + }, { + key: '_getOptionsWithDefaults', + value: function _getOptionsWithDefaults() { + var requestOptions = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + + if (!(requestOptions.visibility || requestOptions.affiliation)) { + requestOptions.type = requestOptions.type || 'all'; + } + requestOptions.sort = requestOptions.sort || 'updated'; + requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line + + return requestOptions; + } + }, { + key: '_dateToISO', + value: function _dateToISO(date) { + if (date && date instanceof Date) { + date = date.toISOString(); + } + + return date; + } + }, { + key: '_request', + value: function _request(method, path, data, cb, raw) { + var url = this.__getURL(path); + + var headers = this.__getRequestHeaders(raw); + // Failsafe check for directly making request from NodeJS + if (!headers['User-Agent']) { + headers['User-Agent'] = 'request'; + } + + var queryParams = {}; + var shouldUseDataAsParams = data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && methodHasNoBody(method); + if (shouldUseDataAsParams) { + queryParams = data; + data = undefined; + } + + var config = { + url: url, + method: method, + headers: headers, + params: queryParams, + data: data, + responseType: raw ? 'text' : 'json' + }; + + log(config.method + ' to ' + config.url); + + var requestPromise = new Promise(function (resolve, reject) { + request(config, function (err, response, body) { + var ret = { + status: response.statusCode, + statusText: response.statusMessage, + headers: response.headers, + config: config + }; + if (err === null && response.statusCode >= 200 && response.statusCode < 300) { + if (raw) { + ret.data = body; + } else { + ret.data = JSON.parse(body); + } + resolve(ret); + } else { + ret.data = body; + callbackErrorOrThrow(cb, path)(ret); + } + }); + }); + // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path)); + + if (cb) { + requestPromise.then(function (response) { + cb(null, response.data || true, response); + }); + } + + return requestPromise; + } + }, { + key: '_request204or404', + value: function _request204or404(path, data, cb) { + var method = arguments.length <= 3 || arguments[3] === undefined ? 'GET' : arguments[3]; + + return this._request(method, path, data).then(function success(response) { + if (cb) { + cb(null, true, response); + } + return true; + }, function failure(response) { + if (response.status === 404) { + if (cb) { + cb(null, false, response); + } + return false; + } + + if (cb) { + cb(response); + } + throw response; + }); + } + }, { + key: '_requestAllPages', + value: function _requestAllPages(path, options, cb, results) { + var _this2 = this; + + results = results || []; + + return this._request('GET', path, options).then(function (response) { + var thisGroup = void 0; + if (response.data instanceof Array) { + thisGroup = response.data; + } else if (response.data.items instanceof Array) { + thisGroup = response.data.items; + } else { + var message = 'cannot figure out how to append ' + response.data + ' to the result set'; + throw new ResponseError(message, path, response); + } + results.push.apply(results, thisGroup); + + var nextUrl = getNextPage(response.headers.link); + if (nextUrl) { + log('getting next page: ' + nextUrl); + return _this2._requestAllPages(nextUrl, options, cb, results); + } + + if (cb) { + cb(null, results, response); + } + + response.data = results; + return response; + }).catch(callbackErrorOrThrow(cb, path)); + } + }]); + + return Requestable; + }(); + + module.exports = Requestable; + + // ////////////////////////// // + // Private helper functions // + // ////////////////////////// // + var METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE']; + function methodHasNoBody(method) { + return METHODS_WITH_NO_BODY.indexOf(method) !== -1; + } + + function getNextPage() { + var linksHeader = arguments.length <= 0 || arguments[0] === undefined ? '' : arguments[0]; + + var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls + return links.reduce(function (nextUrl, link) { + if (link.search(/rel="next"/) !== -1) { + return (link.match(/<(.*)>/) || [])[1]; + } + + return nextUrl; + }, undefined); + } + + function callbackErrorOrThrow(cb, path) { + return function handler(object) { + var error = void 0; + if (object.hasOwnProperty('config')) { + var status = object.status; + var statusText = object.statusText; + var _object$config = object.config; + var method = _object$config.method; + var url = _object$config.url; + + var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"'; + error = new ResponseError(message, path, object); + log(message + ' ' + JSON.stringify(object.data)); + } else { + error = object; + } + if (cb) { + log('going to error callback'); + cb(error); + } else { + log('throwing error'); + throw error; + } + }; + } +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":[],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response.statusCode,\n            statusText: response.statusMessage,\n            headers: response.headers,\n            config: config\n          }\n          if(err === null && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrThrow(cb, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} +//# sourceMappingURL=Requestable.js.map diff --git a/dist/components/Requestable.js.map b/dist/components/Requestable.js.map new file mode 100644 index 00000000..3ca289c0 --- /dev/null +++ b/dist/components/Requestable.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response.statusCode,\n statusText: response.statusMessage,\n headers: response.headers,\n config: config\n }\n if(err === null && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrThrow(cb, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Search.js b/dist/components/Search.js new file mode 100644 index 00000000..f451bba8 --- /dev/null +++ b/dist/components/Search.js @@ -0,0 +1,164 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable', 'debug'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable'), require('debug')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable, global.debug); + global.Search = mod.exports; + } +})(this, function (module, _Requestable2, _debug) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + var _debug2 = _interopRequireDefault(_debug); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var log = (0, _debug2.default)('github:search'); + + /** + * Wrap the Search API + */ + + var Search = function (_Requestable) { + _inherits(Search, _Requestable); + + /** + * Create a Search + * @param {Object} defaults - defaults for the search + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Search(defaults, auth, apiBase) { + _classCallCheck(this, Search); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Search).call(this, auth, apiBase)); + + _this.__defaults = _this._getOptionsWithDefaults(defaults); + return _this; + } + + /** + * Available search options + * @see https://developer.github.com/v3/search/#parameters + * @typedef {Object} Search.Params + * @param {string} q - the query to make + * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`. + * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results) + * @param {string} order - the ordering, either `asc` or `desc` + */ + /** + * Perform a search on the GitHub API + * @private + * @param {string} path - the scope of the search + * @param {Search.Params} [withOptions] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + + _createClass(Search, [{ + key: '_search', + value: function _search(path) { + var _this2 = this; + + var withOptions = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + var cb = arguments.length <= 2 || arguments[2] === undefined ? undefined : arguments[2]; + + var requestOptions = {}; + Object.keys(this.__defaults).forEach(function (prop) { + requestOptions[prop] = _this2.__defaults[prop]; + }); + Object.keys(withOptions).forEach(function (prop) { + requestOptions[prop] = withOptions[prop]; + }); + + log('searching ' + path + ' with options:', requestOptions); + return this._requestAllPages('/search/' + path, requestOptions, cb); + } + }, { + key: 'forRepositories', + value: function forRepositories(options, cb) { + return this._search('repositories', options, cb); + } + }, { + key: 'forCode', + value: function forCode(options, cb) { + return this._search('code', options, cb); + } + }, { + key: 'forIssues', + value: function forIssues(options, cb) { + return this._search('issues', options, cb); + } + }, { + key: 'forUsers', + value: function forUsers(options, cb) { + return this._search('users', options, cb); + } + }]); + + return Search; + }(_Requestable3.default); + + module.exports = Search; +}); +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=Search.js.map diff --git a/dist/components/Search.js.map b/dist/components/Search.js.map new file mode 100644 index 00000000..29bc4bed --- /dev/null +++ b/dist/components/Search.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Search.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n"],"file":"Search.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/Team.js b/dist/components/Team.js new file mode 100644 index 00000000..53e0fcf2 --- /dev/null +++ b/dist/components/Team.js @@ -0,0 +1,174 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable', 'debug'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable'), require('debug')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable, global.debug); + global.Team = mod.exports; + } +})(this, function (module, _Requestable2, _debug) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + var _debug2 = _interopRequireDefault(_debug); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var log = (0, _debug2.default)('github:team'); + + /** + * A Team allows scoping of API requests to a particular Github Organization Team. + */ + + var Team = function (_Requestable) { + _inherits(Team, _Requestable); + + /** + * Create a Team. + * @param {string} [teamId] - the id for the team + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Team(teamId, auth, apiBase) { + _classCallCheck(this, Team); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Team).call(this, auth, apiBase)); + + _this.__teamId = teamId; + return _this; + } + + /** + * Get Team information + * @see https://developer.github.com/v3/orgs/teams/#get-team + * @param {Requestable.callback} [cb] - will receive the team + * @return {Promise} - the promise for the http request + */ + + + _createClass(Team, [{ + key: 'getTeam', + value: function getTeam(cb) { + log('Fetching Team ' + this.__teamId); + return this._request('Get', '/teams/' + this.__teamId, undefined, cb); + } + }, { + key: 'listRepos', + value: function listRepos(cb) { + log('Fetching repositories for Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/repos', undefined, cb); + } + }, { + key: 'editTeam', + value: function editTeam(options, cb) { + log('Editing Team ' + this.__teamId); + return this._request('PATCH', '/teams/' + this.__teamId, options, cb); + } + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + log('Getting members of Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/members', options, cb); + } + }, { + key: 'getMembership', + value: function getMembership(username, cb) { + log('Getting membership of user ' + username + ' in Team ' + this.__teamId); + return this._request('GET', '/teams/' + this.__teamId + '/memberships/' + username, undefined, cb); + } + }, { + key: 'addMembership', + value: function addMembership(username, options, cb) { + log('Adding user ' + username + ' to Team ' + this.__teamId); + return this._request('PUT', '/teams/' + this.__teamId + '/memberships/' + username, options, cb); + } + }, { + key: 'isManagedRepo', + value: function isManagedRepo(owner, repo, cb) { + log('Getting repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb); + } + }, { + key: 'manageRepo', + value: function manageRepo(owner, repo, options, cb) { + log('Adding or Updating repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, options, cb, 'PUT'); + } + }, { + key: 'unmanageRepo', + value: function unmanageRepo(owner, repo, cb) { + log('Remove repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb, 'DELETE'); + } + }, { + key: 'deleteTeam', + value: function deleteTeam(cb) { + log('Deleting Team ' + this.__teamId); + return this._request204or404('/teams/' + this.__teamId, undefined, cb, 'DELETE'); + } + }]); + + return Team; + }(_Requestable3.default); + + module.exports = Team; +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Team.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;MAGM,I;;;AACH;;;;;;AAMA,kBAAY,MAAZ,EAAoB,IAApB,EAA0B,OAA1B,EAAmC;AAAA;;AAAA,0FAC1B,IAD0B,EACpB,OADoB;;AAEhC,YAAK,QAAL,GAAgB,MAAhB;AAFgC;AAGlC;;AAED;;;;;;;;;;8BAMQ,E,EAAI;AACT,+BAAqB,KAAK,QAA1B;AACA,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,EAAgD,SAAhD,EAA2D,EAA3D,CAAP;AACF;;;gCAQS,E,EAAI;AACX,gDAAsC,KAAK,QAA3C;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,aAAuD,SAAvD,EAAkE,EAAlE,CAAP;AACF;;;+BAcQ,O,EAAS,E,EAAI;AACnB,8BAAoB,KAAK,QAAzB;AACA,eAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,QAAtC,EAAkD,OAAlD,EAA2D,EAA3D,CAAP;AACF;;;kCAUW,O,EAAS,E,EAAI;AACtB,yCAA+B,KAAK,QAApC;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;;oCASa,Q,EAAU,E,EAAI;AACzB,4CAAkC,QAAlC,iBAAsD,KAAK,QAA3D;AACA,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;;oCAYa,Q,EAAU,O,EAAS,E,EAAI;AAClC,6BAAmB,QAAnB,iBAAuC,KAAK,QAA5C;AACA,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,OAAxE,EAAiF,EAAjF,CAAP;AACF;;;oCAUa,K,EAAO,I,EAAM,E,EAAI;AAC5B,iDAAuC,KAAK,QAA5C,kBAAiE,KAAjE,SAA0E,IAA1E;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;;iCAaU,K,EAAO,I,EAAM,O,EAAS,E,EAAI;AAClC,4DAAkD,KAAK,QAAvD,kBAA4E,KAA5E,SAAqF,IAArF;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,OAAxE,EAAiF,EAAjF,EAAqF,KAArF,CAAP;AACF;;;mCAUY,K,EAAO,I,EAAM,E,EAAI;AAC3B,gDAAsC,KAAK,QAA3C,kBAAgE,KAAhE,SAAyE,IAAzE;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,EAAuF,QAAvF,CAAP;AACF;;;iCAQU,E,EAAI;AACZ,+BAAqB,KAAK,QAA1B;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,EAAiD,SAAjD,EAA4D,EAA5D,EAAgE,QAAhE,CAAP;AACF;;;;;;AAGJ,SAAO,OAAP,GAAiB,IAAjB","file":"Team.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n"]} +//# sourceMappingURL=Team.js.map diff --git a/dist/components/Team.js.map b/dist/components/Team.js.map new file mode 100644 index 00000000..40b18b47 --- /dev/null +++ b/dist/components/Team.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Team.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n"],"file":"Team.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/dist/components/User.js b/dist/components/User.js new file mode 100644 index 00000000..a279d8da --- /dev/null +++ b/dist/components/User.js @@ -0,0 +1,197 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(['module', './Requestable', 'debug'], factory); + } else if (typeof exports !== "undefined") { + factory(module, require('./Requestable'), require('debug')); + } else { + var mod = { + exports: {} + }; + factory(mod, global.Requestable, global.debug); + global.User = mod.exports; + } +})(this, function (module, _Requestable2, _debug) { + 'use strict'; + + var _Requestable3 = _interopRequireDefault(_Requestable2); + + var _debug2 = _interopRequireDefault(_debug); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + function _possibleConstructorReturn(self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + + var log = (0, _debug2.default)('github:user'); + + /** + * A User allows scoping of API requests to a particular Github user. + */ + + var User = function (_Requestable) { + _inherits(User, _Requestable); + + /** + * Create a User. + * @param {string} [username] - the user to use for user-scoped queries + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function User(username, auth, apiBase) { + _classCallCheck(this, User); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(User).call(this, auth, apiBase)); + + _this.__user = username; + return _this; + } + + /** + * Get the url for the request. (dependent on if we're requesting for the authenticated user or not) + * @private + * @param {string} endpoint - the endpoint being requested + * @return {string} - the resolved endpoint + */ + + + _createClass(User, [{ + key: '__getScopedUrl', + value: function __getScopedUrl(endpoint) { + if (this.__user) { + return endpoint ? '/users/' + this.__user + '/' + endpoint : '/users/' + this.__user; + } else { + // eslint-disable-line + switch (endpoint) { + case '': + return '/user'; + + case 'notifications': + case 'gists': + return '/' + endpoint; + + default: + return '/user/' + endpoint; + } + } + } + }, { + key: 'listRepos', + value: function listRepos(options, cb) { + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options = this._getOptionsWithDefaults(options); + + log('Fetching repositories with options: ' + JSON.stringify(options)); + return this._requestAllPages(this.__getScopedUrl('repos'), options, cb); + } + }, { + key: 'listOrgs', + value: function listOrgs(cb) { + return this._request('GET', this.__getScopedUrl('orgs'), null, cb); + } + }, { + key: 'listGists', + value: function listGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + }, { + key: 'listNotifications', + value: function listNotifications(options, cb) { + options = options || {}; + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options.since = this._dateToISO(options.since); + options.before = this._dateToISO(options.before); + + return this._request('GET', this.__getScopedUrl('notifications'), options, cb); + } + }, { + key: 'getProfile', + value: function getProfile(cb) { + return this._request('GET', this.__getScopedUrl(''), null, cb); + } + }, { + key: 'listStarredRepos', + value: function listStarredRepos(cb) { + var requestOptions = this._getOptionsWithDefaults(); + return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb); + } + }, { + key: 'follow', + value: function follow(username, cb) { + return this._request('PUT', '/user/following/' + this.__user, null, cb); + } + }, { + key: 'unfollow', + value: function unfollow(username, cb) { + return this._request('DELETE', '/user/following/' + this.__user, null, cb); + } + }, { + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/user/repos', options, cb); + } + }]); + + return User; + }(_Requestable3.default); + + module.exports = User; +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["User.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,OAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;OAGM,I;;;AACH;;;;;;AAMA,oBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,6FAC5B,IAD4B,EACtB,OADsB;;AAElC,eAAK,MAAL,GAAc,QAAd;AAFkC;AAGpC;;AAED;;;;;;;;;;wCAMe,Q,EAAU;AACtB,gBAAI,KAAK,MAAT,EAAiB;AACd,sBAAO,uBACM,KAAK,MADX,SACqB,QADrB,eAEM,KAAK,MAFlB;AAKF,aAND,MAMO;AAAE;AACN,uBAAQ,QAAR;AACG,uBAAK,EAAL;AACG,4BAAO,OAAP;;AAEH,uBAAK,eAAL;AACA,uBAAK,OAAL;AACG,kCAAW,QAAX;;AAEH;AACG,uCAAgB,QAAhB;AATN;AAWF;AACH;;;mCASS,O,EAAS,E,EAAI;AACpB,gBAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,oBAAK,OAAL;AACA,yBAAU,EAAV;AACF;;AAED,sBAAU,KAAK,uBAAL,CAA6B,OAA7B,CAAV;;AAEA,yDAA2C,KAAK,SAAL,CAAe,OAAf,CAA3C;AACA,mBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,OAApB,CAAtB,EAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;;kCAQQ,E,EAAI;AACV,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,MAApB,CAArB,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;;mCAQS,E,EAAI;AACX,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,OAApB,CAArB,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;;2CASiB,O,EAAS,E,EAAI;AAC5B,sBAAU,WAAW,EAArB;AACA,gBAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,oBAAK,OAAL;AACA,yBAAU,EAAV;AACF;;AAED,oBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;AACA,oBAAQ,MAAR,GAAiB,KAAK,UAAL,CAAgB,QAAQ,MAAxB,CAAjB;;AAEA,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,eAApB,CAArB,EAA2D,OAA3D,EAAoE,EAApE,CAAP;AACF;;;oCAQU,E,EAAI;AACZ,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,EAApB,CAArB,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;;0CAQgB,E,EAAI;AAClB,gBAAI,iBAAiB,KAAK,uBAAL,EAArB;AACA,mBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,SAApB,CAAtB,EAAsD,cAAtD,EAAsE,EAAtE,CAAP;AACF;;;gCASM,Q,EAAU,E,EAAI;AAClB,mBAAO,KAAK,QAAL,CAAc,KAAd,uBAAwC,KAAK,MAA7C,EAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;;kCASQ,Q,EAAU,E,EAAI;AACpB,mBAAO,KAAK,QAAL,CAAc,QAAd,uBAA2C,KAAK,MAAhD,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;;oCASU,O,EAAS,E,EAAI;AACrB,mBAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,UAAO,OAAP,GAAiB,IAAjB","file":"User.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]} +//# sourceMappingURL=User.js.map diff --git a/dist/components/User.js.map b/dist/components/User.js.map new file mode 100644 index 00000000..8ea85e88 --- /dev/null +++ b/dist/components/User.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["User.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"file":"User.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/package.json b/package.json index d113ad20..62485541 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "github-api", - "version": "2.3.0", + "version": "2.3.1", "license": "BSD-3-Clause-Clear", "description": "A higher-level wrapper around the Github API.", "main": "dist/components/GitHub.js", From 087a97addd201f90df6d25ff1dbcb50593bf5002 Mon Sep 17 00:00:00 2001 From: Randal Pinto Date: Sat, 6 Aug 2016 08:50:12 +0100 Subject: [PATCH 03/11] Protect against possible null response from request-http. --- dist/components/Requestable.js | 10 +++++----- dist/components/Requestable.js.map | 2 +- lib/Requestable.js | 8 ++++---- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/dist/components/Requestable.js b/dist/components/Requestable.js index 45979734..dbca3beb 100644 --- a/dist/components/Requestable.js +++ b/dist/components/Requestable.js @@ -240,12 +240,12 @@ var requestPromise = new Promise(function (resolve, reject) { request(config, function (err, response, body) { var ret = { - status: response.statusCode, - statusText: response.statusMessage, - headers: response.headers, + status: response ? response.statusCode : null, + statusText: response ? response.statusMessage : null, + headers: response ? response.headers : null, config: config }; - if (err === null && response.statusCode >= 200 && response.statusCode < 300) { + if (err === null && response && response.statusCode >= 200 && response.statusCode < 300) { if (raw) { ret.data = body; } else { @@ -379,5 +379,5 @@ }; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":[],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response.statusCode,\n            statusText: response.statusMessage,\n            headers: response.headers,\n            config: config\n          }\n          if(err === null && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrThrow(cb, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":[],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response?response.statusCode:null,\n            statusText: response?response.statusMessage:null,\n            headers: response?response.headers:null,\n            config: config\n          }\n          if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrThrow(cb, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} //# sourceMappingURL=Requestable.js.map diff --git a/dist/components/Requestable.js.map b/dist/components/Requestable.js.map index 3ca289c0..04acc312 100644 --- a/dist/components/Requestable.js.map +++ b/dist/components/Requestable.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response.statusCode,\n statusText: response.statusMessage,\n headers: response.headers,\n config: config\n }\n if(err === null && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrThrow(cb, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response?response.statusCode:null,\n statusText: response?response.statusMessage:null,\n headers: response?response.headers:null,\n config: config\n }\n if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrThrow(cb, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/lib/Requestable.js b/lib/Requestable.js index a984876e..b0536626 100644 --- a/lib/Requestable.js +++ b/lib/Requestable.js @@ -189,12 +189,12 @@ class Requestable { const requestPromise = new Promise((resolve, reject) => { request(config, function(err, response, body) { let ret = { - status: response.statusCode, - statusText: response.statusMessage, - headers: response.headers, + status: response?response.statusCode:null, + statusText: response?response.statusMessage:null, + headers: response?response.headers:null, config: config } - if(err === null && response.statusCode >= 200 && response.statusCode < 300) { + if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) { if(raw) { ret.data = body; } From 272dadab1dcdfe354272c00b22ecad7aa3fdac56 Mon Sep 17 00:00:00 2001 From: Randal Pinto Date: Sun, 7 Aug 2016 19:06:35 +0100 Subject: [PATCH 04/11] Rejecting instead of throwing error outside of promise context. --- dist/components/Requestable.js | 10 ++++++---- dist/components/Requestable.js.map | 2 +- lib/Requestable.js | 8 +++++--- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/dist/components/Requestable.js b/dist/components/Requestable.js index dbca3beb..3a14eaf9 100644 --- a/dist/components/Requestable.js +++ b/dist/components/Requestable.js @@ -254,7 +254,7 @@ resolve(ret); } else { ret.data = body; - callbackErrorOrThrow(cb, path)(ret); + callbackErrorOrRejectOrThrow(cb, reject, path)(ret); } }); }); @@ -323,7 +323,7 @@ response.data = results; return response; - }).catch(callbackErrorOrThrow(cb, path)); + }).catch(callbackErrorOrRejectOrThrow(cb, null, path)); } }]); @@ -353,7 +353,7 @@ }, undefined); } - function callbackErrorOrThrow(cb, path) { + function callbackErrorOrRejectOrThrow(cb, reject, path) { return function handler(object) { var error = void 0; if (object.hasOwnProperty('config')) { @@ -372,6 +372,8 @@ if (cb) { log('going to error callback'); cb(error); + } else if (reject) { + reject(error); } else { log('throwing error'); throw error; @@ -379,5 +381,5 @@ }; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":[],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response?response.statusCode:null,\n            statusText: response?response.statusMessage:null,\n            headers: response?response.headers:null,\n            config: config\n          }\n          if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrThrow(cb, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":[],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response?response.statusCode:null,\n            statusText: response?response.statusMessage:null,\n            headers: response?response.headers:null,\n            config: config\n          }\n          if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrRejectOrThrow(cb, reject, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrRejectOrThrow(cb, null, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrRejectOrThrow(cb, reject, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else if (reject) {\n        reject(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} //# sourceMappingURL=Requestable.js.map diff --git a/dist/components/Requestable.js.map b/dist/components/Requestable.js.map index 04acc312..bafabc1d 100644 --- a/dist/components/Requestable.js.map +++ b/dist/components/Requestable.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response?response.statusCode:null,\n statusText: response?response.statusMessage:null,\n headers: response?response.headers:null,\n config: config\n }\n if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrThrow(cb, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response?response.statusCode:null,\n statusText: response?response.statusMessage:null,\n headers: response?response.headers:null,\n config: config\n }\n if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrRejectOrThrow(cb, reject, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrRejectOrThrow(cb, null, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrRejectOrThrow(cb, reject, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else if (reject) {\n reject(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js","sourceRoot":"/source/"} \ No newline at end of file diff --git a/lib/Requestable.js b/lib/Requestable.js index b0536626..d54e304f 100644 --- a/lib/Requestable.js +++ b/lib/Requestable.js @@ -205,7 +205,7 @@ class Requestable { } else { ret.data = body; - callbackErrorOrThrow(cb, path)(ret); + callbackErrorOrRejectOrThrow(cb, reject, path)(ret); } }); }); @@ -288,7 +288,7 @@ class Requestable { response.data = results; return response; - }).catch(callbackErrorOrThrow(cb, path)); + }).catch(callbackErrorOrRejectOrThrow(cb, null, path)); } } @@ -313,7 +313,7 @@ function getNextPage(linksHeader = '') { }, undefined); } -function callbackErrorOrThrow(cb, path) { +function callbackErrorOrRejectOrThrow(cb, reject, path) { return function handler(object) { let error; if (object.hasOwnProperty('config')) { @@ -327,6 +327,8 @@ function callbackErrorOrThrow(cb, path) { if (cb) { log('going to error callback'); cb(error); + } else if (reject) { + reject(error); } else { log('throwing error'); throw error; From 85e48a3b1863af0ae8ed6b7fb20270c66024334f Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 15:42:40 +0000 Subject: [PATCH 05/11] quick workaround until pagination is done properly. get 100 branches for now --- lib/Repository.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/Repository.js b/lib/Repository.js index de77ae48..58aecd37 100644 --- a/lib/Repository.js +++ b/lib/Repository.js @@ -138,7 +138,7 @@ class Repository extends Requestable { * @return {Promise} - the promise for the http request */ listBranches(cb) { - return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb); + return this._request('GET', `/repos/${this.__fullname}/branches?per_page=100`, null, cb); } /** From bad16456404e6fe5aeddcf3b2def7972663a4448 Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 15:59:44 +0000 Subject: [PATCH 06/11] per_page needs to be pass as an option --- lib/Repository.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/Repository.js b/lib/Repository.js index 58aecd37..08d8c4da 100644 --- a/lib/Repository.js +++ b/lib/Repository.js @@ -138,7 +138,7 @@ class Repository extends Requestable { * @return {Promise} - the promise for the http request */ listBranches(cb) { - return this._request('GET', `/repos/${this.__fullname}/branches?per_page=100`, null, cb); + return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb); } /** From ea29778a9da6af7e39c74ffbf938460a92116713 Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 16:11:07 +0000 Subject: [PATCH 07/11] _requestAllPages for now --- lib/Repository.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/Repository.js b/lib/Repository.js index 08d8c4da..16960605 100644 --- a/lib/Repository.js +++ b/lib/Repository.js @@ -138,7 +138,7 @@ class Repository extends Requestable { * @return {Promise} - the promise for the http request */ listBranches(cb) { - return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb); + return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null, cb); } /** From a2beda4ee8d869e35263a32823c05bbd08718f8e Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 16:30:05 +0000 Subject: [PATCH 08/11] added separate listAllBranches --- lib/Repository.js | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/lib/Repository.js b/lib/Repository.js index 16960605..d85312aa 100644 --- a/lib/Repository.js +++ b/lib/Repository.js @@ -138,7 +138,17 @@ class Repository extends Requestable { * @return {Promise} - the promise for the http request */ listBranches(cb) { - return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null, cb); + return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb); + } + + /** + * List all the branches for the repository (after pagination) + * @see https://developer.github.com/v3/repos/#list-branches + * @param + * @return {Promise} - the promise for the http request + */ + listAllBranches() { + return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null); } /** From e79206778804538f040a9eae6c3819680f82da8b Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 16:55:29 +0000 Subject: [PATCH 09/11] updated dist files --- dist/components/Gist.js | 4 ++-- dist/components/Gist.js.map | 2 +- dist/components/GitHub.js | 4 ++-- dist/components/GitHub.js.map | 2 +- dist/components/Issue.js | 4 ++-- dist/components/Issue.js.map | 2 +- dist/components/Markdown.js | 4 ++-- dist/components/Markdown.js.map | 2 +- dist/components/Organization.js | 4 ++-- dist/components/Organization.js.map | 2 +- dist/components/RateLimit.js | 4 ++-- dist/components/RateLimit.js.map | 2 +- dist/components/Repository.js | 17 +++++++++++------ dist/components/Repository.js.map | 2 +- dist/components/Requestable.js | 22 +++++++++++----------- dist/components/Requestable.js.map | 2 +- dist/components/Search.js | 8 ++++---- dist/components/Search.js.map | 2 +- dist/components/Team.js | 4 ++-- dist/components/Team.js.map | 2 +- dist/components/User.js | 4 ++-- dist/components/User.js.map | 2 +- 22 files changed, 53 insertions(+), 48 deletions(-) diff --git a/dist/components/Gist.js b/dist/components/Gist.js index 6b9bdc8a..ea6ca580 100644 --- a/dist/components/Gist.js +++ b/dist/components/Gist.js @@ -81,7 +81,7 @@ function Gist(id, auth, apiBase) { _classCallCheck(this, Gist); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Gist).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (Gist.__proto__ || Object.getPrototypeOf(Gist)).call(this, auth, apiBase)); _this.__id = id; return _this; @@ -172,5 +172,5 @@ module.exports = Gist; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Gist.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAYM,I;;;AACH;;;;;;AAMA,kBAAY,EAAZ,EAAgB,IAAhB,EAAsB,OAAtB,EAA+B;AAAA;;AAAA,0FACtB,IADsB,EAChB,OADgB;;AAE5B,YAAK,IAAL,GAAY,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;2BAMK,E,EAAI;AACN,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,EAA4C,IAA5C,EAAkD,EAAlD,CAAP;AACF;;;6BASM,I,EAAM,E,EAAI;AAAA;;AACd,eAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,QAAtB,EAAgC,IAAhC,EAAsC,EAAtC,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,iBAAK,IAAL,GAAY,SAAS,IAAT,CAAc,EAA1B;AACA,iBAAO,QAAP;AACF,SAJG,CAAP;AAKF;;;8BAQM,E,EAAI;AACR,eAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,EAA+C,IAA/C,EAAqD,EAArD,CAAP;AACF;;;2BAQI,E,EAAI;AACN,eAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,aAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;;6BASM,I,EAAM,E,EAAI;AACd,eAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;;2BAQI,E,EAAI;AACN,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,YAAiD,IAAjD,EAAuD,EAAvD,CAAP;AACF;;;6BAQM,E,EAAI;AACR,eAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,YAAoD,IAApD,EAA0D,EAA1D,CAAP;AACF;;;gCAQS,E,EAAI;AACX,eAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,YAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;;mCAQY,E,EAAI;AACd,eAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,gBAAsD,IAAtD,EAA4D,EAA5D,CAAP;AACF;;;iCASU,O,EAAS,E,EAAI;AACrB,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,kBAAqD,OAArD,EAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;;oCASa,O,EAAS,E,EAAI;AACxB,eAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,gBAAsD,EAAC,MAAM,OAAP,EAAtD,EAAuE,EAAvE,CAAP;AACF;;;kCAUW,O,EAAS,I,EAAM,E,EAAI;AAC5B,eAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,kBAAuD,OAAvD,EAAkE,EAAC,MAAM,IAAP,EAAlE,EAAgF,EAAhF,CAAP;AACF;;;oCASa,O,EAAS,E,EAAI;AACxB,eAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,kBAAwD,OAAxD,EAAmE,IAAnE,EAAyE,EAAzE,CAAP;AACF;;;;;;AAGJ,SAAO,OAAP,GAAiB,IAAjB","file":"Gist.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Gist.js"],"names":["Gist","id","auth","apiBase","__id","cb","_request","gist","then","response","data","_request204or404","_requestAllPages","comment","body","Requestable","module","exports"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAYMA,I;;;AACH;;;;;;AAMA,kBAAYC,EAAZ,EAAgBC,IAAhB,EAAsBC,OAAtB,EAA+B;AAAA;;AAAA,8GACtBD,IADsB,EAChBC,OADgB;;AAE5B,YAAKC,IAAL,GAAYH,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;2BAMKI,E,EAAI;AACN,eAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKF,IAApC,EAA4C,IAA5C,EAAkDC,EAAlD,CAAP;AACF;;;6BASME,I,EAAMF,E,EAAI;AAAA;;AACd,eAAO,KAAKC,QAAL,CAAc,MAAd,EAAsB,QAAtB,EAAgCC,IAAhC,EAAsCF,EAAtC,EACHG,IADG,CACE,UAACC,QAAD,EAAc;AACjB,iBAAKL,IAAL,GAAYK,SAASC,IAAT,CAAcT,EAA1B;AACA,iBAAOQ,QAAP;AACF,SAJG,CAAP;AAKF;;;8BAQMJ,E,EAAI;AACR,eAAO,KAAKC,QAAL,CAAc,QAAd,cAAkC,KAAKF,IAAvC,EAA+C,IAA/C,EAAqDC,EAArD,CAAP;AACF;;;2BAQIA,E,EAAI;AACN,eAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKF,IAArC,aAAmD,IAAnD,EAAyDC,EAAzD,CAAP;AACF;;;6BASME,I,EAAMF,E,EAAI;AACd,eAAO,KAAKC,QAAL,CAAc,OAAd,cAAiC,KAAKF,IAAtC,EAA8CG,IAA9C,EAAoDF,EAApD,CAAP;AACF;;;2BAQIA,E,EAAI;AACN,eAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKF,IAApC,YAAiD,IAAjD,EAAuDC,EAAvD,CAAP;AACF;;;6BAQMA,E,EAAI;AACR,eAAO,KAAKC,QAAL,CAAc,QAAd,cAAkC,KAAKF,IAAvC,YAAoD,IAApD,EAA0DC,EAA1D,CAAP;AACF;;;gCAQSA,E,EAAI;AACX,eAAO,KAAKM,gBAAL,aAAgC,KAAKP,IAArC,YAAkD,IAAlD,EAAwDC,EAAxD,CAAP;AACF;;;mCAQYA,E,EAAI;AACd,eAAO,KAAKO,gBAAL,aAAgC,KAAKR,IAArC,gBAAsD,IAAtD,EAA4DC,EAA5D,CAAP;AACF;;;iCASUQ,O,EAASR,E,EAAI;AACrB,eAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKF,IAApC,kBAAqDS,OAArD,EAAgE,IAAhE,EAAsER,EAAtE,CAAP;AACF;;;oCASaQ,O,EAASR,E,EAAI;AACxB,eAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKF,IAArC,gBAAsD,EAACU,MAAMD,OAAP,EAAtD,EAAuER,EAAvE,CAAP;AACF;;;kCAUWQ,O,EAASC,I,EAAMT,E,EAAI;AAC5B,eAAO,KAAKC,QAAL,CAAc,OAAd,cAAiC,KAAKF,IAAtC,kBAAuDS,OAAvD,EAAkE,EAACC,MAAMA,IAAP,EAAlE,EAAgFT,EAAhF,CAAP;AACF;;;oCASaQ,O,EAASR,E,EAAI;AACxB,eAAO,KAAKC,QAAL,CAAc,QAAd,cAAkC,KAAKF,IAAvC,kBAAwDS,OAAxD,EAAmE,IAAnE,EAAyER,EAAzE,CAAP;AACF;;;;IAvJeU,qB;;AA0JnBC,SAAOC,OAAP,GAAiBjB,IAAjB","file":"Gist.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n"]} //# sourceMappingURL=Gist.js.map diff --git a/dist/components/Gist.js.map b/dist/components/Gist.js.map index 17233eae..d79a5234 100644 --- a/dist/components/Gist.js.map +++ b/dist/components/Gist.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Gist.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n /**\n * Create a Gist.\n * @param {string} id - the id of the gist (not required when creating a gist)\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase);\n this.__id = id;\n }\n\n /**\n * Fetch a gist.\n * @see https://developer.github.com/v3/gists/#get-a-single-gist\n * @param {Requestable.callback} [cb] - will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n read(cb) {\n return this._request('GET', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Create a new gist.\n * @see https://developer.github.com/v3/gists/#create-a-gist\n * @param {Object} gist - the data for the new gist\n * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n * @return {Promise} - the Promise for the http request\n */\n create(gist, cb) {\n return this._request('POST', '/gists', gist, cb)\n .then((response) => {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n"],"file":"Gist.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Gist.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n /**\n * Create a Gist.\n * @param {string} id - the id of the gist (not required when creating a gist)\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase);\n this.__id = id;\n }\n\n /**\n * Fetch a gist.\n * @see https://developer.github.com/v3/gists/#get-a-single-gist\n * @param {Requestable.callback} [cb] - will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n read(cb) {\n return this._request('GET', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Create a new gist.\n * @see https://developer.github.com/v3/gists/#create-a-gist\n * @param {Object} gist - the data for the new gist\n * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n * @return {Promise} - the Promise for the http request\n */\n create(gist, cb) {\n return this._request('POST', '/gists', gist, cb)\n .then((response) => {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n"],"file":"Gist.js"} \ No newline at end of file diff --git a/dist/components/GitHub.js b/dist/components/GitHub.js index 8d6bc2f5..c2ceb111 100644 --- a/dist/components/GitHub.js +++ b/dist/components/GitHub.js @@ -69,7 +69,7 @@ * @param {string} [apiBase=https://api.github.com] - the base Github API URL */ function GitHub(auth) { - var apiBase = arguments.length <= 1 || arguments[1] === undefined ? 'https://api.github.com' : arguments[1]; + var apiBase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'https://api.github.com'; _classCallCheck(this, GitHub); @@ -147,5 +147,5 @@ module.exports = GitHub; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 //# sourceMappingURL=GitHub.js.map diff --git a/dist/components/GitHub.js.map b/dist/components/GitHub.js.map index 3b6254c6..6da4edcf 100644 --- a/dist/components/GitHub.js.map +++ b/dist/components/GitHub.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["GitHub.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n"],"file":"GitHub.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["GitHub.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n"],"file":"GitHub.js"} \ No newline at end of file diff --git a/dist/components/Issue.js b/dist/components/Issue.js index 7db01b7d..b57f6127 100644 --- a/dist/components/Issue.js +++ b/dist/components/Issue.js @@ -81,7 +81,7 @@ function Issue(repository, auth, apiBase) { _classCallCheck(this, Issue); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Issue).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (Issue.__proto__ || Object.getPrototypeOf(Issue)).call(this, auth, apiBase)); _this.__repository = repository; return _this; @@ -183,5 +183,5 @@ module.exports = Issue; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Issue.js"],"names":[],"mappings":"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","file":"Issue.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n}\n\nmodule.exports = Issue;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Issue.js"],"names":["Issue","repository","auth","apiBase","__repository","issueData","cb","_request","options","_requestAllPages","issue","id","comment","body","milestone","milestoneData","labelData","Requestable","module","exports"],"mappings":"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","file":"Issue.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n}\n\nmodule.exports = Issue;\n"]} //# sourceMappingURL=Issue.js.map diff --git a/dist/components/Issue.js.map b/dist/components/Issue.js.map index 64bc1b9d..ddb0af6d 100644 --- a/dist/components/Issue.js.map +++ b/dist/components/Issue.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Issue.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n}\n\nmodule.exports = Issue;\n"],"file":"Issue.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Issue.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n}\n\nmodule.exports = Issue;\n"],"file":"Issue.js"} \ No newline at end of file diff --git a/dist/components/Markdown.js b/dist/components/Markdown.js index fc6fa3cc..855df7ce 100644 --- a/dist/components/Markdown.js +++ b/dist/components/Markdown.js @@ -81,7 +81,7 @@ function Markdown(auth, apiBase) { _classCallCheck(this, Markdown); - return _possibleConstructorReturn(this, Object.getPrototypeOf(Markdown).call(this, auth, apiBase)); + return _possibleConstructorReturn(this, (Markdown.__proto__ || Object.getPrototypeOf(Markdown)).call(this, auth, apiBase)); } /** @@ -108,5 +108,5 @@ module.exports = Markdown; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 //# sourceMappingURL=Markdown.js.map diff --git a/dist/components/Markdown.js.map b/dist/components/Markdown.js.map index dd128433..c02dc0eb 100644 --- a/dist/components/Markdown.js.map +++ b/dist/components/Markdown.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Markdown.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass Markdown extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n"],"file":"Markdown.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Markdown.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass Markdown extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n"],"file":"Markdown.js"} \ No newline at end of file diff --git a/dist/components/Organization.js b/dist/components/Organization.js index fc05a4c3..e5a05429 100644 --- a/dist/components/Organization.js +++ b/dist/components/Organization.js @@ -81,7 +81,7 @@ function Organization(organization, auth, apiBase) { _classCallCheck(this, Organization); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Organization).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (Organization.__proto__ || Object.getPrototypeOf(Organization)).call(this, auth, apiBase)); _this.__name = organization; return _this; @@ -135,5 +135,5 @@ module.exports = Organization; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIk9yZ2FuaXphdGlvbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztNQVlNLFk7OztBQUNIOzs7Ozs7QUFNQSwwQkFBWSxZQUFaLEVBQTBCLElBQTFCLEVBQWdDLE9BQWhDLEVBQXlDO0FBQUE7O0FBQUEsa0dBQ2hDLElBRGdDLEVBQzFCLE9BRDBCOztBQUV0QyxZQUFLLE1BQUwsR0FBYyxZQUFkO0FBRnNDO0FBR3hDOztBQUVEOzs7Ozs7Ozs7OztpQ0FPVyxPLEVBQVMsRSxFQUFJO0FBQ3JCLGVBQU8sS0FBSyxRQUFMLENBQWMsTUFBZCxhQUErQixLQUFLLE1BQXBDLGFBQW9ELE9BQXBELEVBQTZELEVBQTdELENBQVA7QUFDRjs7OytCQVFRLEUsRUFBSTtBQUNWLFlBQUksaUJBQWlCLEtBQUssdUJBQUwsQ0FBNkIsRUFBQyxXQUFXLE1BQVosRUFBN0IsQ0FBckI7O0FBRUEsZUFBTyxLQUFLLGdCQUFMLFlBQStCLEtBQUssTUFBcEMsYUFBb0QsY0FBcEQsRUFBb0UsRUFBcEUsQ0FBUDtBQUNGOzs7K0JBUVEsUSxFQUFVLEUsRUFBSTtBQUNwQixlQUFPLEtBQUssZ0JBQUwsWUFBK0IsS0FBSyxNQUFwQyxpQkFBc0QsUUFBdEQsRUFBa0UsSUFBbEUsRUFBd0UsRUFBeEUsQ0FBUDtBQUNGOzs7a0NBV1csTyxFQUFTLEUsRUFBSTtBQUN0QixlQUFPLEtBQUssUUFBTCxDQUFjLEtBQWQsYUFBOEIsS0FBSyxNQUFuQyxlQUFxRCxPQUFyRCxFQUE4RCxFQUE5RCxDQUFQO0FBQ0Y7OzsrQkFRUSxFLEVBQUk7QUFDVixlQUFPLEtBQUssZ0JBQUwsWUFBK0IsS0FBSyxNQUFwQyxhQUFvRCxTQUFwRCxFQUErRCxFQUEvRCxDQUFQO0FBQ0Y7OztpQ0FjVSxPLEVBQVMsRSxFQUFJO0FBQ3JCLGVBQU8sS0FBSyxRQUFMLENBQWMsTUFBZCxhQUErQixLQUFLLE1BQXBDLGFBQW9ELE9BQXBELEVBQTZELEVBQTdELENBQVA7QUFDRjs7Ozs7O0FBR0osU0FBTyxPQUFQLEdBQWlCLFlBQWpCIiwiZmlsZSI6Ik9yZ2FuaXphdGlvbi5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGZpbGVcbiAqIEBjb3B5cmlnaHQgIDIwMTMgTWljaGFlbCBBdWZyZWl0ZXIgKERldmVsb3BtZW50IFNlZWQpIGFuZCAyMDE2IFlhaG9vIEluYy5cbiAqIEBsaWNlbnNlICAgIExpY2Vuc2VkIHVuZGVyIHtAbGluayBodHRwczovL3NwZHgub3JnL2xpY2Vuc2VzL0JTRC0zLUNsYXVzZS1DbGVhci5odG1sIEJTRC0zLUNsYXVzZS1DbGVhcn0uXG4gKiAgICAgICAgICAgICBHaXRodWIuanMgaXMgZnJlZWx5IGRpc3RyaWJ1dGFibGUuXG4gKi9cblxuaW1wb3J0IFJlcXVlc3RhYmxlIGZyb20gJy4vUmVxdWVzdGFibGUnO1xuXG4vKipcbiAqIE9yZ2FuaXphdGlvbiBlbmNhcHN1bGF0ZXMgdGhlIGZ1bmN0aW9uYWxpdHkgdG8gY3JlYXRlIHJlcG9zaXRvcmllcyBpbiBvcmdhbml6YXRpb25zXG4gKi9cbmNsYXNzIE9yZ2FuaXphdGlvbiBleHRlbmRzIFJlcXVlc3RhYmxlIHtcbiAgIC8qKlxuICAgICogQ3JlYXRlIGEgbmV3IE9yZ2FuaXphdGlvblxuICAgICogQHBhcmFtIHtzdHJpbmd9IG9yZ2FuaXphdGlvbiAtIHRoZSBuYW1lIG9mIHRoZSBvcmdhbml6YXRpb25cbiAgICAqIEBwYXJhbSB7UmVxdWVzdGFibGUuYXV0aH0gW2F1dGhdIC0gaW5mb3JtYXRpb24gcmVxdWlyZWQgdG8gYXV0aGVudGljYXRlIHRvIEdpdGh1YlxuICAgICogQHBhcmFtIHtzdHJpbmd9IFthcGlCYXNlPWh0dHBzOi8vYXBpLmdpdGh1Yi5jb21dIC0gdGhlIGJhc2UgR2l0aHViIEFQSSBVUkxcbiAgICAqL1xuICAgY29uc3RydWN0b3Iob3JnYW5pemF0aW9uLCBhdXRoLCBhcGlCYXNlKSB7XG4gICAgICBzdXBlcihhdXRoLCBhcGlCYXNlKTtcbiAgICAgIHRoaXMuX19uYW1lID0gb3JnYW5pemF0aW9uO1xuICAgfVxuXG4gICAvKipcbiAgICAqIENyZWF0ZSBhIHJlcG9zaXRvcnkgaW4gYW4gb3JnYW5pemF0aW9uXG4gICAgKiBAc2VlIGh0dHBzOi8vZGV2ZWxvcGVyLmdpdGh1Yi5jb20vdjMvcmVwb3MvI2NyZWF0ZVxuICAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMgLSB0aGUgcmVwb3NpdG9yeSBkZWZpbml0aW9uXG4gICAgKiBAcGFyYW0ge1JlcXVlc3RhYmxlLmNhbGxiYWNrfSBbY2JdIC0gd2lsbCByZWNlaXZlIHRoZSBjcmVhdGVkIHJlcG9zaXRvcnlcbiAgICAqIEByZXR1cm4ge1Byb21pc2V9IC0gdGhlIHByb21pc2UgZm9yIHRoZSBodHRwIHJlcXVlc3RcbiAgICAqL1xuICAgY3JlYXRlUmVwbyhvcHRpb25zLCBjYikge1xuICAgICAgcmV0dXJuIHRoaXMuX3JlcXVlc3QoJ1BPU1QnLCBgL29yZ3MvJHt0aGlzLl9fbmFtZX0vcmVwb3NgLCBvcHRpb25zLCBjYik7XG4gICB9XG5cbiAgIC8qKlxuICAgICogTGlzdCB0aGUgcmVwb3NpdG9yaWVzIGluIGFuIG9yZ2FuaXphdGlvblxuICAgICogQHNlZSBodHRwczovL2RldmVsb3Blci5naXRodWIuY29tL3YzL3JlcG9zLyNsaXN0LW9yZ2FuaXphdGlvbi1yZXBvc2l0b3JpZXNcbiAgICAqIEBwYXJhbSB7UmVxdWVzdGFibGUuY2FsbGJhY2t9IFtjYl0gLSB3aWxsIHJlY2VpdmUgdGhlIGxpc3Qgb2YgcmVwb3NpdG9yaWVzXG4gICAgKiBAcmV0dXJuIHtQcm9taXNlfSAtIHRoZSBwcm9taXNlIGZvciB0aGUgaHR0cCByZXF1ZXN0XG4gICAgKi9cbiAgIGdldFJlcG9zKGNiKSB7XG4gICAgICBsZXQgcmVxdWVzdE9wdGlvbnMgPSB0aGlzLl9nZXRPcHRpb25zV2l0aERlZmF1bHRzKHtkaXJlY3Rpb246ICdkZXNjJ30pO1xuXG4gICAgICByZXR1cm4gdGhpcy5fcmVxdWVzdEFsbFBhZ2VzKGAvb3Jncy8ke3RoaXMuX19uYW1lfS9yZXBvc2AsIHJlcXVlc3RPcHRpb25zLCBjYik7XG4gICB9XG5cbiAgIC8qKlxuICAgICogUXVlcnkgaWYgdGhlIHVzZXIgaXMgYSBtZW1iZXIgb3Igbm90XG4gICAgKiBAcGFyYW0ge3N0cmluZ30gdXNlcm5hbWUgLSB0aGUgdXNlciBpbiBxdWVzdGlvblxuICAgICogQHBhcmFtIHtSZXF1ZXN0YWJsZS5jYWxsYmFja30gW2NiXSAtIHdpbGwgcmVjZWl2ZSB0cnVlIGlmIHRoZSB1c2VyIGlzIGEgbWVtYmVyXG4gICAgKiBAcmV0dXJuIHtQcm9taXNlfSAtIHRoZSBwcm9taXNlIGZvciB0aGUgaHR0cCByZXF1ZXN0XG4gICAgKi9cbiAgIGlzTWVtYmVyKHVzZXJuYW1lLCBjYikge1xuICAgICAgcmV0dXJuIHRoaXMuX3JlcXVlc3QyMDRvcjQwNChgL29yZ3MvJHt0aGlzLl9fbmFtZX0vbWVtYmVycy8ke3VzZXJuYW1lfWAsIG51bGwsIGNiKTtcbiAgIH1cblxuICAgLyoqXG4gICAgKiBMaXN0IHRoZSB1c2VycyB3aG8gYXJlIG1lbWJlcnMgb2YgdGhlIGNvbXBhbnlcbiAgICAqIEBzZWUgaHR0cHM6Ly9kZXZlbG9wZXIuZ2l0aHViLmNvbS92My9vcmdzL21lbWJlcnMvI21lbWJlcnMtbGlzdFxuICAgICogQHBhcmFtIHtvYmplY3R9IG9wdGlvbnMgLSBmaWx0ZXJpbmcgb3B0aW9uc1xuICAgICogQHBhcmFtIHtzdHJpbmd9IFtvcHRpb25zLmZpbHRlcj1hbGxdIC0gY2FuIGJlIGVpdGhlciBgMmZhX2Rpc2FibGVkYCBvciBgYWxsYFxuICAgICogQHBhcmFtIHtzdHJpbmd9IFtvcHRpb25zLnJvbGU9YWxsXSAtIGNhbiBiZSBvbmUgb2Y6IGBhbGxgLCBgYWRtaW5gLCBvciBgbWVtYmVyYFxuICAgICogQHBhcmFtIHtSZXF1ZXN0YWJsZS5jYWxsYmFja30gW2NiXSAtIHdpbGwgcmVjZWl2ZSB0aGUgbGlzdCBvZiB1c2Vyc1xuICAgICogQHJldHVybiB7UHJvbWlzZX0gLSB0aGUgcHJvbWlzZSBmb3IgdGhlIGh0dHAgcmVxdWVzdFxuICAgICovXG4gICBsaXN0TWVtYmVycyhvcHRpb25zLCBjYikge1xuICAgICAgcmV0dXJuIHRoaXMuX3JlcXVlc3QoJ0dFVCcsIGAvb3Jncy8ke3RoaXMuX19uYW1lfS9tZW1iZXJzYCwgb3B0aW9ucywgY2IpO1xuICAgfVxuXG4gICAvKipcbiAgICAqIExpc3QgdGhlIFRlYW1zIGluIHRoZSBPcmdhbml6YXRpb25cbiAgICAqIEBzZWUgaHR0cHM6Ly9kZXZlbG9wZXIuZ2l0aHViLmNvbS92My9vcmdzL3RlYW1zLyNsaXN0LXRlYW1zXG4gICAgKiBAcGFyYW0ge1JlcXVlc3RhYmxlLmNhbGxiYWNrfSBbY2JdIC0gd2lsbCByZWNlaXZlIHRoZSBsaXN0IG9mIHRlYW1zXG4gICAgKiBAcmV0dXJuIHtQcm9taXNlfSAtIHRoZSBwcm9taXNlIGZvciB0aGUgaHR0cCByZXF1ZXN0XG4gICAgKi9cbiAgIGdldFRlYW1zKGNiKSB7XG4gICAgICByZXR1cm4gdGhpcy5fcmVxdWVzdEFsbFBhZ2VzKGAvb3Jncy8ke3RoaXMuX19uYW1lfS90ZWFtc2AsIHVuZGVmaW5lZCwgY2IpO1xuICAgfVxuXG4gICAvKipcbiAgICAqIENyZWF0ZSBhIHRlYW1cbiAgICAqIEBzZWUgaHR0cHM6Ly9kZXZlbG9wZXIuZ2l0aHViLmNvbS92My9vcmdzL3RlYW1zLyNjcmVhdGUtdGVhbVxuICAgICogQHBhcmFtIHtvYmplY3R9IG9wdGlvbnMgLSBUZWFtIGNyZWF0aW9uIHBhcmFtZXRlcnNcbiAgICAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLm5hbWUgLSBUaGUgbmFtZSBvZiB0aGUgdGVhbVxuICAgICogQHBhcmFtIHtzdHJpbmd9IFtvcHRpb25zLmRlc2NyaXB0aW9uXSAtIFRlYW0gZGVzY3JpcHRpb25cbiAgICAqIEBwYXJhbSB7c3RyaW5nfSBbb3B0aW9ucy5yZXBvX25hbWVzXSAtIFJlcG9zIHRvIGFkZCB0aGUgdGVhbSB0b1xuICAgICogQHBhcmFtIHtzdHJpbmd9IFtvcHRpb25zLnByaXZhY3k9c2VjcmV0XSAtIFRoZSBsZXZlbCBvZiBwcml2YWN5IHRoZSB0ZWFtIHNob3VsZCBoYXZlLiBDYW4gYmUgZWl0aGVyIG9uZVxuICAgICogb2Y6IGBzZWNyZXRgLCBvciBgY2xvc2VkYFxuICAgICogQHBhcmFtIHtSZXF1ZXN0YWJsZS5jYWxsYmFja30gW2NiXSAtIHdpbGwgcmVjZWl2ZSB0aGUgY3JlYXRlZCB0ZWFtXG4gICAgKiBAcmV0dXJuIHtQcm9taXNlfSAtIHRoZSBwcm9taXNlIGZvciB0aGUgaHR0cCByZXF1ZXN0XG4gICAgKi9cbiAgIGNyZWF0ZVRlYW0ob3B0aW9ucywgY2IpIHtcbiAgICAgIHJldHVybiB0aGlzLl9yZXF1ZXN0KCdQT1NUJywgYC9vcmdzLyR7dGhpcy5fX25hbWV9L3RlYW1zYCwgb3B0aW9ucywgY2IpO1xuICAgfVxufVxuXG5tb2R1bGUuZXhwb3J0cyA9IE9yZ2FuaXphdGlvbjtcbiJdfQ== +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 //# sourceMappingURL=Organization.js.map diff --git a/dist/components/Organization.js.map b/dist/components/Organization.js.map index 67f2838d..c7a02304 100644 --- a/dist/components/Organization.js.map +++ b/dist/components/Organization.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Organization.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n"],"file":"Organization.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Organization.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n"],"file":"Organization.js"} \ No newline at end of file diff --git a/dist/components/RateLimit.js b/dist/components/RateLimit.js index 87ed0ccf..b53c6813 100644 --- a/dist/components/RateLimit.js +++ b/dist/components/RateLimit.js @@ -81,7 +81,7 @@ function RateLimit(auth, apiBase) { _classCallCheck(this, RateLimit); - return _possibleConstructorReturn(this, Object.getPrototypeOf(RateLimit).call(this, auth, apiBase)); + return _possibleConstructorReturn(this, (RateLimit.__proto__ || Object.getPrototypeOf(RateLimit)).call(this, auth, apiBase)); } /** @@ -104,5 +104,5 @@ module.exports = RateLimit; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 //# sourceMappingURL=RateLimit.js.map diff --git a/dist/components/RateLimit.js.map b/dist/components/RateLimit.js.map index 8cae1491..8ae70e98 100644 --- a/dist/components/RateLimit.js.map +++ b/dist/components/RateLimit.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["RateLimit.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n"],"file":"RateLimit.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["RateLimit.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n"],"file":"RateLimit.js"} \ No newline at end of file diff --git a/dist/components/Repository.js b/dist/components/Repository.js index 512829cc..96628e35 100644 --- a/dist/components/Repository.js +++ b/dist/components/Repository.js @@ -28,7 +28,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; function _classCallCheck(instance, Constructor) { @@ -97,7 +97,7 @@ function Repository(fullname, auth, apiBase) { _classCallCheck(this, Repository); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Repository).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (Repository.__proto__ || Object.getPrototypeOf(Repository)).call(this, auth, apiBase)); _this.__fullname = fullname; _this.__currentTree = { @@ -167,6 +167,11 @@ value: function listBranches(cb) { return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); } + }, { + key: 'listAllBranches', + value: function listAllBranches() { + return this._requestAllPages('GET', '/repos/' + this.__fullname + '/branches', null); + } }, { key: 'getBlob', value: function getBlob(sha, cb) { @@ -414,9 +419,9 @@ var object = _ref.data.object; return _this5.getTree(object.sha + '?recursive=true'); }).then(function (_ref2) { - var _ref2$data = _ref2.data; - var tree = _ref2$data.tree; - var sha = _ref2$data.sha; + var _ref2$data = _ref2.data, + tree = _ref2$data.tree, + sha = _ref2$data.sha; oldSha = sha; var newTree = tree.map(function (ref) { @@ -515,5 +520,5 @@ module.exports = Repository; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Repository.js"],"names":[],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Repository.js"],"names":["log","Repository","fullname","auth","apiBase","__fullname","__currentTree","branch","sha","ref","cb","_request","options","number","base","head","_requestAllPages","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","Utf8","encode","encoding","Buffer","toString","Blob","Base64","JSON","stringify","Error","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","data","parents","then","response","commitSHA","force","username","raw","encodeURI","oldBranch","newBranch","getRef","object","createRef","id","__repoPath","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","Requestable","module","exports"],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n   \n   /**\n    * List all the branches for the repository (after pagination)\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param\n    * @return {Promise} - the promise for the http request\n    */   \n   listAllBranches() {\n      return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} //# sourceMappingURL=Repository.js.map diff --git a/dist/components/Repository.js.map b/dist/components/Repository.js.map index 6acc27a7..edee38a6 100644 --- a/dist/components/Repository.js.map +++ b/dist/components/Repository.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n \n /**\n * List all the branches for the repository (after pagination)\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param\n * @return {Promise} - the promise for the http request\n */ \n listAllBranches() {\n return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js"} \ No newline at end of file diff --git a/dist/components/Requestable.js b/dist/components/Requestable.js index 3a14eaf9..74316e94 100644 --- a/dist/components/Requestable.js +++ b/dist/components/Requestable.js @@ -28,7 +28,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; var _createClass = function () { @@ -109,7 +109,7 @@ function ResponseError(message, path, response) { _classCallCheck(this, ResponseError); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ResponseError).call(this, message)); + var _this = _possibleConstructorReturn(this, (ResponseError.__proto__ || Object.getPrototypeOf(ResponseError)).call(this, message)); _this.path = path; _this.request = response.config; @@ -189,7 +189,7 @@ }, { key: '_getOptionsWithDefaults', value: function _getOptionsWithDefaults() { - var requestOptions = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; if (!(requestOptions.visibility || requestOptions.affiliation)) { requestOptions.type = requestOptions.type || 'all'; @@ -271,7 +271,7 @@ }, { key: '_request204or404', value: function _request204or404(path, data, cb) { - var method = arguments.length <= 3 || arguments[3] === undefined ? 'GET' : arguments[3]; + var method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'GET'; return this._request(method, path, data).then(function success(response) { if (cb) { @@ -341,7 +341,7 @@ } function getNextPage() { - var linksHeader = arguments.length <= 0 || arguments[0] === undefined ? '' : arguments[0]; + var linksHeader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls return links.reduce(function (nextUrl, link) { @@ -357,11 +357,11 @@ return function handler(object) { var error = void 0; if (object.hasOwnProperty('config')) { - var status = object.status; - var statusText = object.statusText; - var _object$config = object.config; - var method = _object$config.method; - var url = _object$config.url; + var status = object.status, + statusText = object.statusText, + _object$config = object.config, + method = _object$config.method, + url = _object$config.url; var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"'; error = new ResponseError(message, path, object); @@ -381,5 +381,5 @@ }; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":[],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response?response.statusCode:null,\n            statusText: response?response.statusMessage:null,\n            headers: response?response.headers:null,\n            config: config\n          }\n          if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrRejectOrThrow(cb, reject, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrRejectOrThrow(cb, null, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrRejectOrThrow(cb, reject, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else if (reject) {\n        reject(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Requestable.js"],"names":["httpRequestCache","RequestHttpCache","max","request","extensions","extension","log","Promise","ResponseError","message","path","response","config","status","Error","Requestable","auth","apiBase","__apiBase","__auth","token","username","password","__authorizationHeader","Base64","encode","url","indexOf","newCacheBuster","Date","getTime","replace","raw","headers","Authorization","requestOptions","visibility","affiliation","type","sort","per_page","date","toISOString","method","data","cb","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","methodHasNoBody","undefined","params","responseType","requestPromise","resolve","reject","err","body","ret","statusCode","statusText","statusMessage","JSON","parse","callbackErrorOrRejectOrThrow","then","_request","success","failure","options","results","thisGroup","Array","items","push","apply","nextUrl","getNextPage","link","_requestAllPages","catch","module","exports","METHODS_WITH_NO_BODY","linksHeader","links","split","reduce","search","match","handler","object","error","hasOwnProperty","stringify"],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n  max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n  extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n   polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password\n      };\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw) {\n      let headers = {\n         'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n         'Content-Type': 'application/json;charset=UTF-8'\n      };\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      let headers = this.__getRequestHeaders(raw);\n      // Failsafe check for directly making request from NodeJS\n      if(!headers['User-Agent']) {\n        headers['User-Agent'] = 'request';\n      }\n\n      let queryParams = {};\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json'\n      };\n\n      log(`${config.method} to ${config.url}`);\n\n      const requestPromise = new Promise((resolve, reject) => {\n        request(config, function(err, response, body) {\n          let ret = {\n            status: response?response.statusCode:null,\n            statusText: response?response.statusMessage:null,\n            headers: response?response.headers:null,\n            config: config\n          }\n          if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n            if(raw) {\n              ret.data = body;\n            }\n            else {\n              ret.data = JSON.parse(body);\n            }\n            resolve(ret);\n          }\n          else {\n            ret.data = body;\n            callbackErrorOrRejectOrThrow(cb, reject, path)(ret);\n          }\n        });\n      });\n      // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            cb(null, response.data || true, response);\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push.apply(results, thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl) {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrRejectOrThrow(cb, null, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrRejectOrThrow(cb, reject, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {status, statusText, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else if (reject) {\n        reject(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} //# sourceMappingURL=Requestable.js.map diff --git a/dist/components/Requestable.js.map b/dist/components/Requestable.js.map index bafabc1d..88123f8e 100644 --- a/dist/components/Requestable.js.map +++ b/dist/components/Requestable.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response?response.statusCode:null,\n statusText: response?response.statusMessage:null,\n headers: response?response.headers:null,\n config: config\n }\n if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrRejectOrThrow(cb, reject, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrRejectOrThrow(cb, null, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrRejectOrThrow(cb, reject, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else if (reject) {\n reject(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport requestExt from 'request-extensible';\nimport RequestHttpCache from 'request-http-cache';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\nimport {polyfill} from 'es6-promise';\n\nconst httpRequestCache = new RequestHttpCache({\n max: 256*1024*1024 // Maximum cache size (256mb)\n});\n\nconst request = requestExt({\n extensions: [ httpRequestCache.extension ]\n});\n\nconst log = debug('github:request');\n\nif (typeof Promise === 'undefined') {\n polyfill();\n}\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password\n };\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw) {\n let headers = {\n 'Accept': raw ? 'application/vnd.github.v3.raw+json' : 'application/vnd.github.v3+json',\n 'Content-Type': 'application/json;charset=UTF-8'\n };\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n let headers = this.__getRequestHeaders(raw);\n // Failsafe check for directly making request from NodeJS\n if(!headers['User-Agent']) {\n headers['User-Agent'] = 'request';\n }\n\n let queryParams = {};\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json'\n };\n\n log(`${config.method} to ${config.url}`);\n\n const requestPromise = new Promise((resolve, reject) => {\n request(config, function(err, response, body) {\n let ret = {\n status: response?response.statusCode:null,\n statusText: response?response.statusMessage:null,\n headers: response?response.headers:null,\n config: config\n }\n if(err === null && response && response.statusCode >= 200 && response.statusCode < 300) {\n if(raw) {\n ret.data = body;\n }\n else {\n ret.data = JSON.parse(body);\n }\n resolve(ret);\n }\n else {\n ret.data = body;\n callbackErrorOrRejectOrThrow(cb, reject, path)(ret);\n }\n });\n });\n // const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n cb(null, response.data || true, response);\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push.apply(results, thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl) {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrRejectOrThrow(cb, null, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrRejectOrThrow(cb, reject, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {status, statusText, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else if (reject) {\n reject(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js"} \ No newline at end of file diff --git a/dist/components/Search.js b/dist/components/Search.js index f451bba8..4cfc7d75 100644 --- a/dist/components/Search.js +++ b/dist/components/Search.js @@ -89,7 +89,7 @@ function Search(defaults, auth, apiBase) { _classCallCheck(this, Search); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Search).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (Search.__proto__ || Object.getPrototypeOf(Search)).call(this, auth, apiBase)); _this.__defaults = _this._getOptionsWithDefaults(defaults); return _this; @@ -119,8 +119,8 @@ value: function _search(path) { var _this2 = this; - var withOptions = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; - var cb = arguments.length <= 2 || arguments[2] === undefined ? undefined : arguments[2]; + var withOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var cb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined; var requestOptions = {}; Object.keys(this.__defaults).forEach(function (prop) { @@ -160,5 +160,5 @@ module.exports = Search; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIlNlYXJjaC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBU0EsTUFBTSxNQUFNLHFCQUFNLGVBQU4sQ0FBWjs7QUFFQTs7OztNQUdNLE07OztBQUNIOzs7Ozs7QUFNQSxvQkFBWSxRQUFaLEVBQXNCLElBQXRCLEVBQTRCLE9BQTVCLEVBQXFDO0FBQUE7O0FBQUEsNEZBQzVCLElBRDRCLEVBQ3RCLE9BRHNCOztBQUVsQyxZQUFLLFVBQUwsR0FBa0IsTUFBSyx1QkFBTCxDQUE2QixRQUE3QixDQUFsQjtBQUZrQztBQUdwQzs7QUFFRDs7Ozs7Ozs7O0FBU0E7Ozs7Ozs7Ozs7Ozs4QkFRUSxJLEVBQXdDO0FBQUE7O0FBQUEsWUFBbEMsV0FBa0MseURBQXBCLEVBQW9CO0FBQUEsWUFBaEIsRUFBZ0IseURBQVgsU0FBVzs7QUFDN0MsWUFBSSxpQkFBaUIsRUFBckI7QUFDQSxlQUFPLElBQVAsQ0FBWSxLQUFLLFVBQWpCLEVBQTZCLE9BQTdCLENBQXFDLFVBQUMsSUFBRCxFQUFVO0FBQzVDLHlCQUFlLElBQWYsSUFBdUIsT0FBSyxVQUFMLENBQWdCLElBQWhCLENBQXZCO0FBQ0YsU0FGRDtBQUdBLGVBQU8sSUFBUCxDQUFZLFdBQVosRUFBeUIsT0FBekIsQ0FBaUMsVUFBQyxJQUFELEVBQVU7QUFDeEMseUJBQWUsSUFBZixJQUF1QixZQUFZLElBQVosQ0FBdkI7QUFDRixTQUZEOztBQUlBLDJCQUFpQixJQUFqQixxQkFBdUMsY0FBdkM7QUFDQSxlQUFPLEtBQUssZ0JBQUwsY0FBaUMsSUFBakMsRUFBeUMsY0FBekMsRUFBeUQsRUFBekQsQ0FBUDtBQUNGOzs7c0NBU2UsTyxFQUFTLEUsRUFBSTtBQUMxQixlQUFPLEtBQUssT0FBTCxDQUFhLGNBQWIsRUFBNkIsT0FBN0IsRUFBc0MsRUFBdEMsQ0FBUDtBQUNGOzs7OEJBU08sTyxFQUFTLEUsRUFBSTtBQUNsQixlQUFPLEtBQUssT0FBTCxDQUFhLE1BQWIsRUFBcUIsT0FBckIsRUFBOEIsRUFBOUIsQ0FBUDtBQUNGOzs7Z0NBU1MsTyxFQUFTLEUsRUFBSTtBQUNwQixlQUFPLEtBQUssT0FBTCxDQUFhLFFBQWIsRUFBdUIsT0FBdkIsRUFBZ0MsRUFBaEMsQ0FBUDtBQUNGOzs7K0JBU1EsTyxFQUFTLEUsRUFBSTtBQUNuQixlQUFPLEtBQUssT0FBTCxDQUFhLE9BQWIsRUFBc0IsT0FBdEIsRUFBK0IsRUFBL0IsQ0FBUDtBQUNGOzs7Ozs7QUFHSixTQUFPLE9BQVAsR0FBaUIsTUFBakIiLCJmaWxlIjoiU2VhcmNoLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZmlsZVxuICogQGNvcHlyaWdodCAgMjAxMyBNaWNoYWVsIEF1ZnJlaXRlciAoRGV2ZWxvcG1lbnQgU2VlZCkgYW5kIDIwMTYgWWFob28gSW5jLlxuICogQGxpY2Vuc2UgICAgTGljZW5zZWQgdW5kZXIge0BsaW5rIGh0dHBzOi8vc3BkeC5vcmcvbGljZW5zZXMvQlNELTMtQ2xhdXNlLUNsZWFyLmh0bWwgQlNELTMtQ2xhdXNlLUNsZWFyfS5cbiAqICAgICAgICAgICAgIEdpdGh1Yi5qcyBpcyBmcmVlbHkgZGlzdHJpYnV0YWJsZS5cbiAqL1xuXG5pbXBvcnQgUmVxdWVzdGFibGUgZnJvbSAnLi9SZXF1ZXN0YWJsZSc7XG5pbXBvcnQgZGVidWcgZnJvbSAnZGVidWcnO1xuY29uc3QgbG9nID0gZGVidWcoJ2dpdGh1YjpzZWFyY2gnKTtcblxuLyoqXG4gKiBXcmFwIHRoZSBTZWFyY2ggQVBJXG4gKi9cbmNsYXNzIFNlYXJjaCBleHRlbmRzIFJlcXVlc3RhYmxlIHtcbiAgIC8qKlxuICAgICogQ3JlYXRlIGEgU2VhcmNoXG4gICAgKiBAcGFyYW0ge09iamVjdH0gZGVmYXVsdHMgLSBkZWZhdWx0cyBmb3IgdGhlIHNlYXJjaFxuICAgICogQHBhcmFtIHtSZXF1ZXN0YWJsZS5hdXRofSBbYXV0aF0gLSBpbmZvcm1hdGlvbiByZXF1aXJlZCB0byBhdXRoZW50aWNhdGUgdG8gR2l0aHViXG4gICAgKiBAcGFyYW0ge3N0cmluZ30gW2FwaUJhc2U9aHR0cHM6Ly9hcGkuZ2l0aHViLmNvbV0gLSB0aGUgYmFzZSBHaXRodWIgQVBJIFVSTFxuICAgICovXG4gICBjb25zdHJ1Y3RvcihkZWZhdWx0cywgYXV0aCwgYXBpQmFzZSkge1xuICAgICAgc3VwZXIoYXV0aCwgYXBpQmFzZSk7XG4gICAgICB0aGlzLl9fZGVmYXVsdHMgPSB0aGlzLl9nZXRPcHRpb25zV2l0aERlZmF1bHRzKGRlZmF1bHRzKTtcbiAgIH1cblxuICAgLyoqXG4gICAgKiBBdmFpbGFibGUgc2VhcmNoIG9wdGlvbnNcbiAgICAqIEBzZWUgaHR0cHM6Ly9kZXZlbG9wZXIuZ2l0aHViLmNvbS92My9zZWFyY2gvI3BhcmFtZXRlcnNcbiAgICAqIEB0eXBlZGVmIHtPYmplY3R9IFNlYXJjaC5QYXJhbXNcbiAgICAqIEBwYXJhbSB7c3RyaW5nfSBxIC0gdGhlIHF1ZXJ5IHRvIG1ha2VcbiAgICAqIEBwYXJhbSB7c3RyaW5nfSBzb3J0IC0gdGhlIHNvcnQgZmllbGQsIG9uZSBvZiBgc3RhcnNgLCBgZm9ya3NgLCBvciBgdXBkYXRlZGAuXG4gICAgKiAgICAgICAgICAgICAgICAgICAgICBEZWZhdWx0IGlzIFtiZXN0IG1hdGNoXShodHRwczovL2RldmVsb3Blci5naXRodWIuY29tL3YzL3NlYXJjaC8jcmFua2luZy1zZWFyY2gtcmVzdWx0cylcbiAgICAqIEBwYXJhbSB7c3RyaW5nfSBvcmRlciAtIHRoZSBvcmRlcmluZywgZWl0aGVyIGBhc2NgIG9yIGBkZXNjYFxuICAgICovXG4gICAvKipcbiAgICAqIFBlcmZvcm0gYSBzZWFyY2ggb24gdGhlIEdpdEh1YiBBUElcbiAgICAqIEBwcml2YXRlXG4gICAgKiBAcGFyYW0ge3N0cmluZ30gcGF0aCAtIHRoZSBzY29wZSBvZiB0aGUgc2VhcmNoXG4gICAgKiBAcGFyYW0ge1NlYXJjaC5QYXJhbXN9IFt3aXRoT3B0aW9uc10gLSBhZGRpdGlvbmFsIHBhcmFtZXRlcnMgZm9yIHRoZSBzZWFyY2hcbiAgICAqIEBwYXJhbSB7UmVxdWVzdGFibGUuY2FsbGJhY2t9IFtjYl0gLSB3aWxsIHJlY2VpdmUgdGhlIHJlc3VsdHMgb2YgdGhlIHNlYXJjaFxuICAgICogQHJldHVybiB7UHJvbWlzZX0gLSB0aGUgcHJvbWlzZSBmb3IgdGhlIGh0dHAgcmVxdWVzdFxuICAgICovXG4gICBfc2VhcmNoKHBhdGgsIHdpdGhPcHRpb25zID0ge30sIGNiID0gdW5kZWZpbmVkKSB7XG4gICAgICBsZXQgcmVxdWVzdE9wdGlvbnMgPSB7fTtcbiAgICAgIE9iamVjdC5rZXlzKHRoaXMuX19kZWZhdWx0cykuZm9yRWFjaCgocHJvcCkgPT4ge1xuICAgICAgICAgcmVxdWVzdE9wdGlvbnNbcHJvcF0gPSB0aGlzLl9fZGVmYXVsdHNbcHJvcF07XG4gICAgICB9KTtcbiAgICAgIE9iamVjdC5rZXlzKHdpdGhPcHRpb25zKS5mb3JFYWNoKChwcm9wKSA9PiB7XG4gICAgICAgICByZXF1ZXN0T3B0aW9uc1twcm9wXSA9IHdpdGhPcHRpb25zW3Byb3BdO1xuICAgICAgfSk7XG5cbiAgICAgIGxvZyhgc2VhcmNoaW5nICR7cGF0aH0gd2l0aCBvcHRpb25zOmAsIHJlcXVlc3RPcHRpb25zKTtcbiAgICAgIHJldHVybiB0aGlzLl9yZXF1ZXN0QWxsUGFnZXMoYC9zZWFyY2gvJHtwYXRofWAsIHJlcXVlc3RPcHRpb25zLCBjYik7XG4gICB9XG5cbiAgIC8qKlxuICAgICogU2VhcmNoIGZvciByZXBvc2l0b3JpZXNcbiAgICAqIEBzZWUgaHR0cHM6Ly9kZXZlbG9wZXIuZ2l0aHViLmNvbS92My9zZWFyY2gvI3NlYXJjaC1yZXBvc2l0b3JpZXNcbiAgICAqIEBwYXJhbSB7U2VhcmNoLlBhcmFtc30gW29wdGlvbnNdIC0gYWRkaXRpb25hbCBwYXJhbWV0ZXJzIGZvciB0aGUgc2VhcmNoXG4gICAgKiBAcGFyYW0ge1JlcXVlc3RhYmxlLmNhbGxiYWNrfSBbY2JdIC0gd2lsbCByZWNlaXZlIHRoZSByZXN1bHRzIG9mIHRoZSBzZWFyY2hcbiAgICAqIEByZXR1cm4ge1Byb21pc2V9IC0gdGhlIHByb21pc2UgZm9yIHRoZSBodHRwIHJlcXVlc3RcbiAgICAqL1xuICAgZm9yUmVwb3NpdG9yaWVzKG9wdGlvbnMsIGNiKSB7XG4gICAgICByZXR1cm4gdGhpcy5fc2VhcmNoKCdyZXBvc2l0b3JpZXMnLCBvcHRpb25zLCBjYik7XG4gICB9XG5cbiAgIC8qKlxuICAgICogU2VhcmNoIGZvciBjb2RlXG4gICAgKiBAc2VlIGh0dHBzOi8vZGV2ZWxvcGVyLmdpdGh1Yi5jb20vdjMvc2VhcmNoLyNzZWFyY2gtY29kZVxuICAgICogQHBhcmFtIHtTZWFyY2guUGFyYW1zfSBbb3B0aW9uc10gLSBhZGRpdGlvbmFsIHBhcmFtZXRlcnMgZm9yIHRoZSBzZWFyY2hcbiAgICAqIEBwYXJhbSB7UmVxdWVzdGFibGUuY2FsbGJhY2t9IFtjYl0gLSB3aWxsIHJlY2VpdmUgdGhlIHJlc3VsdHMgb2YgdGhlIHNlYXJjaFxuICAgICogQHJldHVybiB7UHJvbWlzZX0gLSB0aGUgcHJvbWlzZSBmb3IgdGhlIGh0dHAgcmVxdWVzdFxuICAgICovXG4gICBmb3JDb2RlKG9wdGlvbnMsIGNiKSB7XG4gICAgICByZXR1cm4gdGhpcy5fc2VhcmNoKCdjb2RlJywgb3B0aW9ucywgY2IpO1xuICAgfVxuXG4gICAvKipcbiAgICAqIFNlYXJjaCBmb3IgaXNzdWVzXG4gICAgKiBAc2VlIGh0dHBzOi8vZGV2ZWxvcGVyLmdpdGh1Yi5jb20vdjMvc2VhcmNoLyNzZWFyY2gtaXNzdWVzXG4gICAgKiBAcGFyYW0ge1NlYXJjaC5QYXJhbXN9IFtvcHRpb25zXSAtIGFkZGl0aW9uYWwgcGFyYW1ldGVycyBmb3IgdGhlIHNlYXJjaFxuICAgICogQHBhcmFtIHtSZXF1ZXN0YWJsZS5jYWxsYmFja30gW2NiXSAtIHdpbGwgcmVjZWl2ZSB0aGUgcmVzdWx0cyBvZiB0aGUgc2VhcmNoXG4gICAgKiBAcmV0dXJuIHtQcm9taXNlfSAtIHRoZSBwcm9taXNlIGZvciB0aGUgaHR0cCByZXF1ZXN0XG4gICAgKi9cbiAgIGZvcklzc3VlcyhvcHRpb25zLCBjYikge1xuICAgICAgcmV0dXJuIHRoaXMuX3NlYXJjaCgnaXNzdWVzJywgb3B0aW9ucywgY2IpO1xuICAgfVxuXG4gICAvKipcbiAgICAqIFNlYXJjaCBmb3IgdXNlcnNcbiAgICAqIEBzZWUgaHR0cHM6Ly9kZXZlbG9wZXIuZ2l0aHViLmNvbS92My9zZWFyY2gvI3NlYXJjaC11c2Vyc1xuICAgICogQHBhcmFtIHtTZWFyY2guUGFyYW1zfSBbb3B0aW9uc10gLSBhZGRpdGlvbmFsIHBhcmFtZXRlcnMgZm9yIHRoZSBzZWFyY2hcbiAgICAqIEBwYXJhbSB7UmVxdWVzdGFibGUuY2FsbGJhY2t9IFtjYl0gLSB3aWxsIHJlY2VpdmUgdGhlIHJlc3VsdHMgb2YgdGhlIHNlYXJjaFxuICAgICogQHJldHVybiB7UHJvbWlzZX0gLSB0aGUgcHJvbWlzZSBmb3IgdGhlIGh0dHAgcmVxdWVzdFxuICAgICovXG4gICBmb3JVc2VycyhvcHRpb25zLCBjYikge1xuICAgICAgcmV0dXJuIHRoaXMuX3NlYXJjaCgndXNlcnMnLCBvcHRpb25zLCBjYik7XG4gICB9XG59XG5cbm1vZHVsZS5leHBvcnRzID0gU2VhcmNoO1xuIl19 +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 //# sourceMappingURL=Search.js.map diff --git a/dist/components/Search.js.map b/dist/components/Search.js.map index 29bc4bed..9276c5e8 100644 --- a/dist/components/Search.js.map +++ b/dist/components/Search.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Search.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n"],"file":"Search.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Search.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n"],"file":"Search.js"} \ No newline at end of file diff --git a/dist/components/Team.js b/dist/components/Team.js index 53e0fcf2..0e0ab4be 100644 --- a/dist/components/Team.js +++ b/dist/components/Team.js @@ -89,7 +89,7 @@ function Team(teamId, auth, apiBase) { _classCallCheck(this, Team); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Team).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (Team.__proto__ || Object.getPrototypeOf(Team)).call(this, auth, apiBase)); _this.__teamId = teamId; return _this; @@ -170,5 +170,5 @@ module.exports = Team; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Team.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;MAGM,I;;;AACH;;;;;;AAMA,kBAAY,MAAZ,EAAoB,IAApB,EAA0B,OAA1B,EAAmC;AAAA;;AAAA,0FAC1B,IAD0B,EACpB,OADoB;;AAEhC,YAAK,QAAL,GAAgB,MAAhB;AAFgC;AAGlC;;AAED;;;;;;;;;;8BAMQ,E,EAAI;AACT,+BAAqB,KAAK,QAA1B;AACA,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,EAAgD,SAAhD,EAA2D,EAA3D,CAAP;AACF;;;gCAQS,E,EAAI;AACX,gDAAsC,KAAK,QAA3C;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,aAAuD,SAAvD,EAAkE,EAAlE,CAAP;AACF;;;+BAcQ,O,EAAS,E,EAAI;AACnB,8BAAoB,KAAK,QAAzB;AACA,eAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,QAAtC,EAAkD,OAAlD,EAA2D,EAA3D,CAAP;AACF;;;kCAUW,O,EAAS,E,EAAI;AACtB,yCAA+B,KAAK,QAApC;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;;oCASa,Q,EAAU,E,EAAI;AACzB,4CAAkC,QAAlC,iBAAsD,KAAK,QAA3D;AACA,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;;oCAYa,Q,EAAU,O,EAAS,E,EAAI;AAClC,6BAAmB,QAAnB,iBAAuC,KAAK,QAA5C;AACA,eAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,OAAxE,EAAiF,EAAjF,CAAP;AACF;;;oCAUa,K,EAAO,I,EAAM,E,EAAI;AAC5B,iDAAuC,KAAK,QAA5C,kBAAiE,KAAjE,SAA0E,IAA1E;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;;iCAaU,K,EAAO,I,EAAM,O,EAAS,E,EAAI;AAClC,4DAAkD,KAAK,QAAvD,kBAA4E,KAA5E,SAAqF,IAArF;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,OAAxE,EAAiF,EAAjF,EAAqF,KAArF,CAAP;AACF;;;mCAUY,K,EAAO,I,EAAM,E,EAAI;AAC3B,gDAAsC,KAAK,QAA3C,kBAAgE,KAAhE,SAAyE,IAAzE;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,EAAuF,QAAvF,CAAP;AACF;;;iCAQU,E,EAAI;AACZ,+BAAqB,KAAK,QAA1B;AACA,eAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,EAAiD,SAAjD,EAA4D,EAA5D,EAAgE,QAAhE,CAAP;AACF;;;;;;AAGJ,SAAO,OAAP,GAAiB,IAAjB","file":"Team.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Team.js"],"names":["log","Team","teamId","auth","apiBase","__teamId","cb","_request","undefined","_requestAllPages","options","username","owner","repo","_request204or404","Requestable","module","exports"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MAAMA,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;MAGMC,I;;;AACH;;;;;;AAMA,kBAAYC,MAAZ,EAAoBC,IAApB,EAA0BC,OAA1B,EAAmC;AAAA;;AAAA,8GAC1BD,IAD0B,EACpBC,OADoB;;AAEhC,YAAKC,QAAL,GAAgBH,MAAhB;AAFgC;AAGlC;;AAED;;;;;;;;;;8BAMQI,E,EAAI;AACTN,+BAAqB,KAAKK,QAA1B;AACA,eAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKF,QAApC,EAAgDG,SAAhD,EAA2DF,EAA3D,CAAP;AACF;;;gCAQSA,E,EAAI;AACXN,gDAAsC,KAAKK,QAA3C;AACA,eAAO,KAAKI,gBAAL,aAAgC,KAAKJ,QAArC,aAAuDG,SAAvD,EAAkEF,EAAlE,CAAP;AACF;;;+BAcQI,O,EAASJ,E,EAAI;AACnBN,8BAAoB,KAAKK,QAAzB;AACA,eAAO,KAAKE,QAAL,CAAc,OAAd,cAAiC,KAAKF,QAAtC,EAAkDK,OAAlD,EAA2DJ,EAA3D,CAAP;AACF;;;kCAUWI,O,EAASJ,E,EAAI;AACtBN,yCAA+B,KAAKK,QAApC;AACA,eAAO,KAAKI,gBAAL,aAAgC,KAAKJ,QAArC,eAAyDK,OAAzD,EAAkEJ,EAAlE,CAAP;AACF;;;oCASaK,Q,EAAUL,E,EAAI;AACzBN,4CAAkCW,QAAlC,iBAAsD,KAAKN,QAA3D;AACA,eAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKF,QAApC,qBAA4DM,QAA5D,EAAwEH,SAAxE,EAAmFF,EAAnF,CAAP;AACF;;;oCAYaK,Q,EAAUD,O,EAASJ,E,EAAI;AAClCN,6BAAmBW,QAAnB,iBAAuC,KAAKN,QAA5C;AACA,eAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKF,QAApC,qBAA4DM,QAA5D,EAAwED,OAAxE,EAAiFJ,EAAjF,CAAP;AACF;;;oCAUaM,K,EAAOC,I,EAAMP,E,EAAI;AAC5BN,iDAAuC,KAAKK,QAA5C,kBAAiEO,KAAjE,SAA0EC,IAA1E;AACA,eAAO,KAAKC,gBAAL,aAAgC,KAAKT,QAArC,eAAuDO,KAAvD,SAAgEC,IAAhE,EAAwEL,SAAxE,EAAmFF,EAAnF,CAAP;AACF;;;iCAaUM,K,EAAOC,I,EAAMH,O,EAASJ,E,EAAI;AAClCN,4DAAkD,KAAKK,QAAvD,kBAA4EO,KAA5E,SAAqFC,IAArF;AACA,eAAO,KAAKC,gBAAL,aAAgC,KAAKT,QAArC,eAAuDO,KAAvD,SAAgEC,IAAhE,EAAwEH,OAAxE,EAAiFJ,EAAjF,EAAqF,KAArF,CAAP;AACF;;;mCAUYM,K,EAAOC,I,EAAMP,E,EAAI;AAC3BN,gDAAsC,KAAKK,QAA3C,kBAAgEO,KAAhE,SAAyEC,IAAzE;AACA,eAAO,KAAKC,gBAAL,aAAgC,KAAKT,QAArC,eAAuDO,KAAvD,SAAgEC,IAAhE,EAAwEL,SAAxE,EAAmFF,EAAnF,EAAuF,QAAvF,CAAP;AACF;;;iCAQUA,E,EAAI;AACZN,+BAAqB,KAAKK,QAA1B;AACA,eAAO,KAAKS,gBAAL,aAAgC,KAAKT,QAArC,EAAiDG,SAAjD,EAA4DF,EAA5D,EAAgE,QAAhE,CAAP;AACF;;;;IA9IeS,qB;;AAiJnBC,SAAOC,OAAP,GAAiBhB,IAAjB","file":"Team.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n"]} //# sourceMappingURL=Team.js.map diff --git a/dist/components/Team.js.map b/dist/components/Team.js.map index 40b18b47..d7323e92 100644 --- a/dist/components/Team.js.map +++ b/dist/components/Team.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Team.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n"],"file":"Team.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Team.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n"],"file":"Team.js"} \ No newline at end of file diff --git a/dist/components/User.js b/dist/components/User.js index a279d8da..7972a491 100644 --- a/dist/components/User.js +++ b/dist/components/User.js @@ -89,7 +89,7 @@ function User(username, auth, apiBase) { _classCallCheck(this, User); - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(User).call(this, auth, apiBase)); + var _this = _possibleConstructorReturn(this, (User.__proto__ || Object.getPrototypeOf(User)).call(this, auth, apiBase)); _this.__user = username; return _this; @@ -193,5 +193,5 @@ module.exports = User; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["User.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,OAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;OAGM,I;;;AACH;;;;;;AAMA,oBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,6FAC5B,IAD4B,EACtB,OADsB;;AAElC,eAAK,MAAL,GAAc,QAAd;AAFkC;AAGpC;;AAED;;;;;;;;;;wCAMe,Q,EAAU;AACtB,gBAAI,KAAK,MAAT,EAAiB;AACd,sBAAO,uBACM,KAAK,MADX,SACqB,QADrB,eAEM,KAAK,MAFlB;AAKF,aAND,MAMO;AAAE;AACN,uBAAQ,QAAR;AACG,uBAAK,EAAL;AACG,4BAAO,OAAP;;AAEH,uBAAK,eAAL;AACA,uBAAK,OAAL;AACG,kCAAW,QAAX;;AAEH;AACG,uCAAgB,QAAhB;AATN;AAWF;AACH;;;mCASS,O,EAAS,E,EAAI;AACpB,gBAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,oBAAK,OAAL;AACA,yBAAU,EAAV;AACF;;AAED,sBAAU,KAAK,uBAAL,CAA6B,OAA7B,CAAV;;AAEA,yDAA2C,KAAK,SAAL,CAAe,OAAf,CAA3C;AACA,mBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,OAApB,CAAtB,EAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;;kCAQQ,E,EAAI;AACV,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,MAApB,CAArB,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;;mCAQS,E,EAAI;AACX,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,OAApB,CAArB,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;;2CASiB,O,EAAS,E,EAAI;AAC5B,sBAAU,WAAW,EAArB;AACA,gBAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,oBAAK,OAAL;AACA,yBAAU,EAAV;AACF;;AAED,oBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;AACA,oBAAQ,MAAR,GAAiB,KAAK,UAAL,CAAgB,QAAQ,MAAxB,CAAjB;;AAEA,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,eAApB,CAArB,EAA2D,OAA3D,EAAoE,EAApE,CAAP;AACF;;;oCAQU,E,EAAI;AACZ,mBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,EAApB,CAArB,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;;0CAQgB,E,EAAI;AAClB,gBAAI,iBAAiB,KAAK,uBAAL,EAArB;AACA,mBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,SAApB,CAAtB,EAAsD,cAAtD,EAAsE,EAAtE,CAAP;AACF;;;gCASM,Q,EAAU,E,EAAI;AAClB,mBAAO,KAAK,QAAL,CAAc,KAAd,uBAAwC,KAAK,MAA7C,EAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;;kCASQ,Q,EAAU,E,EAAI;AACpB,mBAAO,KAAK,QAAL,CAAc,QAAd,uBAA2C,KAAK,MAAhD,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;;oCASU,O,EAAS,E,EAAI;AACrB,mBAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,UAAO,OAAP,GAAiB,IAAjB","file":"User.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["User.js"],"names":["log","User","username","auth","apiBase","__user","endpoint","options","cb","_getOptionsWithDefaults","JSON","stringify","_requestAllPages","__getScopedUrl","_request","since","_dateToISO","before","requestOptions","Requestable","module","exports"],"mappings":"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","file":"User.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]} //# sourceMappingURL=User.js.map diff --git a/dist/components/User.js.map b/dist/components/User.js.map index 8ea85e88..c5bec5e6 100644 --- a/dist/components/User.js.map +++ b/dist/components/User.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["User.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"file":"User.js","sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["User.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"file":"User.js"} \ No newline at end of file From b97fed9b57e3b14c01946352684458bfb6d154d2 Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 17:08:30 +0000 Subject: [PATCH 10/11] increase per_page to 100 --- dist/components/Repository.js | 4 ++-- dist/components/Repository.js.map | 2 +- lib/Repository.js | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dist/components/Repository.js b/dist/components/Repository.js index 96628e35..8153450e 100644 --- a/dist/components/Repository.js +++ b/dist/components/Repository.js @@ -165,7 +165,7 @@ }, { key: 'listBranches', value: function listBranches(cb) { - return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); + return this._request('GET', '/repos/' + this.__fullname + '/branches', { per_page: 100 }, cb); } }, { key: 'listAllBranches', @@ -520,5 +520,5 @@ module.exports = Repository; }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Repository.js"],"names":["log","Repository","fullname","auth","apiBase","__fullname","__currentTree","branch","sha","ref","cb","_request","options","number","base","head","_requestAllPages","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","Utf8","encode","encoding","Buffer","toString","Blob","Base64","JSON","stringify","Error","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","data","parents","then","response","commitSHA","force","username","raw","encodeURI","oldBranch","newBranch","getRef","object","createRef","id","__repoPath","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","Requestable","module","exports"],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n   \n   /**\n    * List all the branches for the repository (after pagination)\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param\n    * @return {Promise} - the promise for the http request\n    */   \n   listAllBranches() {\n      return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Repository.js"],"names":["log","Repository","fullname","auth","apiBase","__fullname","__currentTree","branch","sha","ref","cb","_request","options","number","base","head","per_page","_requestAllPages","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","Utf8","encode","encoding","Buffer","toString","Blob","Base64","JSON","stringify","Error","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","data","parents","then","response","commitSHA","force","username","raw","encodeURI","oldBranch","newBranch","getRef","object","createRef","id","__repoPath","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","Requestable","module","exports"],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb);\n   }\n   \n   /**\n    * List all the branches for the repository (after pagination)\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param\n    * @return {Promise} - the promise for the http request\n    */   \n   listAllBranches() {\n      return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} //# sourceMappingURL=Repository.js.map diff --git a/dist/components/Repository.js.map b/dist/components/Repository.js.map index edee38a6..7151f8a2 100644 --- a/dist/components/Repository.js.map +++ b/dist/components/Repository.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n \n /**\n * List all the branches for the repository (after pagination)\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param\n * @return {Promise} - the promise for the http request\n */ \n listAllBranches() {\n return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb);\n }\n \n /**\n * List all the branches for the repository (after pagination)\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param\n * @return {Promise} - the promise for the http request\n */ \n listAllBranches() {\n return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js"} \ No newline at end of file diff --git a/lib/Repository.js b/lib/Repository.js index d85312aa..6fc2d6a6 100644 --- a/lib/Repository.js +++ b/lib/Repository.js @@ -138,7 +138,7 @@ class Repository extends Requestable { * @return {Promise} - the promise for the http request */ listBranches(cb) { - return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb); + return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb); } /** From 90c72852d4eb042a60309d67a426002d2d1060ae Mon Sep 17 00:00:00 2001 From: Deepak Prabhakara Date: Sat, 21 Dec 2019 17:49:19 +0000 Subject: [PATCH 11/11] fixed listAllBranches --- dist/components/Repository.js | 6 +++--- dist/components/Repository.js.map | 2 +- lib/Repository.js | 10 +++++----- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/dist/components/Repository.js b/dist/components/Repository.js index 8153450e..81b69d9c 100644 --- a/dist/components/Repository.js +++ b/dist/components/Repository.js @@ -165,12 +165,12 @@ }, { key: 'listBranches', value: function listBranches(cb) { - return this._request('GET', '/repos/' + this.__fullname + '/branches', { per_page: 100 }, cb); + return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); } }, { key: 'listAllBranches', value: function listAllBranches() { - return this._requestAllPages('GET', '/repos/' + this.__fullname + '/branches', null); + return this._requestAllPages('/repos/' + this.__fullname + '/branches', null); } }, { key: 'getBlob', @@ -520,5 +520,5 @@ module.exports = Repository; }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Repository.js"],"names":["log","Repository","fullname","auth","apiBase","__fullname","__currentTree","branch","sha","ref","cb","_request","options","number","base","head","per_page","_requestAllPages","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","Utf8","encode","encoding","Buffer","toString","Blob","Base64","JSON","stringify","Error","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","data","parents","then","response","commitSHA","force","username","raw","encodeURI","oldBranch","newBranch","getRef","object","createRef","id","__repoPath","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","Requestable","module","exports"],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb);\n   }\n   \n   /**\n    * List all the branches for the repository (after pagination)\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param\n    * @return {Promise} - the promise for the http request\n    */   \n   listAllBranches() {\n      return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Repository.js"],"names":["log","Repository","fullname","auth","apiBase","__fullname","__currentTree","branch","sha","ref","cb","_request","options","number","base","head","_requestAllPages","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","Utf8","encode","encoding","Buffer","toString","Blob","Base64","JSON","stringify","Error","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","data","parents","then","response","commitSHA","force","username","raw","encodeURI","oldBranch","newBranch","getRef","object","createRef","id","__repoPath","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","Requestable","module","exports"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,OAAMA,MAAM,qBAAM,mBAAN,CAAZ;;AAEA;;;;OAGMC,U;;;AACH;;;;;;AAMA,0BAAYC,QAAZ,EAAsBC,IAAtB,EAA4BC,OAA5B,EAAqC;AAAA;;AAAA,6HAC5BD,IAD4B,EACtBC,OADsB;;AAElC,eAAKC,UAAL,GAAkBH,QAAlB;AACA,eAAKI,aAAL,GAAqB;AAClBC,oBAAQ,IADU;AAElBC,iBAAK;AAFa,UAArB;AAHkC;AAOpC;;AAED;;;;;;;;;;;gCAOOC,G,EAAKC,E,EAAI;AACb,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,kBAA2DI,GAA3D,EAAkE,IAAlE,EAAwEC,EAAxE,CAAP;AACF;;;mCASSE,O,EAASF,E,EAAI;AACpB,mBAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,gBAA4DO,OAA5D,EAAqEF,EAArE,CAAP;AACF;;;mCASSD,G,EAAKC,E,EAAI;AAChB,mBAAO,KAAKC,QAAL,CAAc,QAAd,cAAkC,KAAKN,UAAvC,kBAA8DI,GAA9D,EAAqE,IAArE,EAA2EC,EAA3E,CAAP;AACF;;;oCAQUA,E,EAAI;AACZ,mBAAO,KAAKC,QAAL,CAAc,QAAd,cAAkC,KAAKN,UAAvC,EAAqD,IAArD,EAA2DK,EAA3D,CAAP;AACF;;;kCAQQA,E,EAAI;AACV,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,YAAuD,IAAvD,EAA6DK,EAA7D,CAAP;AACF;;;0CASgBE,O,EAASF,E,EAAI;AAC3BE,sBAAUA,WAAW,EAArB;AACA,mBAAO,KAAKD,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,aAAwDO,OAAxD,EAAiEF,EAAjE,CAAP;AACF;;;wCAScG,M,EAAQH,E,EAAI;AACxB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,eAAwDQ,MAAxD,EAAkE,IAAlE,EAAwEH,EAAxE,CAAP;AACF;;;8CASoBG,M,EAAQH,E,EAAI;AAC9B,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,eAAwDQ,MAAxD,aAAwE,IAAxE,EAA8EH,EAA9E,CAAP;AACF;;;yCAUeI,I,EAAMC,I,EAAML,E,EAAI;AAC7B,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,iBAA0DS,IAA1D,WAAoEC,IAApE,EAA4E,IAA5E,EAAkFL,EAAlF,CAAP;AACF;;;sCAQYA,E,EAAI;AACd,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,gBAA2D,IAA3D,EAAiEK,EAAjE,CAAP;AACF;;;2CAQiB;AACf,mBAAO,KAAKM,gBAAL,aAAgC,KAAKX,UAArC,gBAA4D,IAA5D,CAAP;AACF;;;iCASOG,G,EAAKE,E,EAAI;AACd,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,mBAA4DG,GAA5D,EAAmE,IAAnE,EAAyEE,EAAzE,EAA6E,KAA7E,CAAP;AACF;;;mCASSF,G,EAAKE,E,EAAI;AAChB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,qBAA8DG,GAA9D,EAAqE,IAArE,EAA2EE,EAA3E,CAAP;AACF;;;qCAcWE,O,EAASF,E,EAAI;AACtBE,sBAAUA,WAAW,EAArB;;AAEAA,oBAAQK,KAAR,GAAgB,KAAKC,UAAL,CAAgBN,QAAQK,KAAxB,CAAhB;AACAL,oBAAQO,KAAR,GAAgB,KAAKD,UAAL,CAAgBN,QAAQO,KAAxB,CAAhB;;AAEA,mBAAO,KAAKR,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,eAA0DO,OAA1D,EAAmEF,EAAnE,CAAP;AACF;;;yCASeD,G,EAAKC,E,EAAI;AACtBD,kBAAMA,OAAO,EAAb;AACA,mBAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,iBAA0DI,GAA1D,EAAiE,IAAjE,EAAuEC,EAAvE,CAAP;AACF;;;gCAUMH,M,EAAQa,I,EAAMV,E,EAAI;AACtBH,qBAASA,mBAAiBA,MAAjB,GAA4B,EAArC;AACA,mBAAO,KAAKI,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,kBAA2De,IAA3D,GAAkEb,MAAlE,EAA4E,IAA5E,EAAkFG,EAAlF,CAAP;AACF;;;sCASYF,G,EAAKE,E,EAAI;AACnB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,iBAA0DG,GAA1D,gBAA0E,IAA1E,EAAgFE,EAAhF,CAAP;AACF;;;iCASOW,O,EAASX,E,EAAI;AAClB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,mBAA4DgB,OAA5D,EAAuE,IAAvE,EAA6EX,EAA7E,CAAP;AACF;;;oCASUY,O,EAASZ,E,EAAI;AACrB,gBAAIa,WAAW,KAAKC,iBAAL,CAAuBF,OAAvB,CAAf;;AAEAtB,gBAAI,iBAAJ,EAAuBuB,QAAvB;AACA,mBAAO,KAAKZ,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,iBAA6DkB,QAA7D,EAAuEb,EAAvE,CAAP;AACF;;;2CAOiBY,O,EAAS;AACxB,gBAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;AAC9BtB,mBAAI,oBAAJ;AACA,sBAAO;AACJsB,2BAASG,cAAKC,MAAL,CAAYJ,OAAZ,CADL;AAEJK,4BAAU;AAFN,gBAAP;AAKF,aAPD,MAOO,IAAI,OAAOC,MAAP,KAAkB,WAAlB,IAAiCN,mBAAmBM,MAAxD,EAAgE;AACpE5B,mBAAI,yBAAJ;AACA,sBAAO;AACJsB,2BAASA,QAAQO,QAAR,CAAiB,QAAjB,CADL;AAEJF,4BAAU;AAFN,gBAAP;AAKF,aAPM,MAOA,IAAI,OAAOG,IAAP,KAAgB,WAAhB,IAA+BR,mBAAmBQ,IAAtD,EAA4D;AAChE9B,mBAAI,gCAAJ;AACA,sBAAO;AACJsB,2BAASS,eAAOL,MAAP,CAAcJ,OAAd,CADL;AAEJK,4BAAU;AAFN,gBAAP;AAKF,aAPM,MAOA;AAAE;AACN3B,+DAA6CsB,OAA7C,yCAA6CA,OAA7C,YAAyDU,KAAKC,SAAL,CAAeX,OAAf,CAAzD;AACA,qBAAM,IAAIY,KAAJ,CAAU,mFAAV,CAAN;AACF;AACH;;;oCAYUC,W,EAAaf,I,EAAMgB,O,EAAS1B,E,EAAI;AACxC,gBAAI2B,UAAU;AACXC,0BAAWH,WADA,EACa;AACxBI,qBAAM,CAAC;AACJnB,wBAAMA,IADF;AAEJZ,uBAAK4B,OAFD;AAGJI,wBAAM,QAHF;AAIJC,wBAAM;AAJF,gBAAD;AAFK,aAAd;;AAUA,mBAAO,KAAK9B,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,iBAA6DgC,OAA7D,EAAsE3B,EAAtE,CAAP;AACF;;;oCAUU6B,I,EAAMG,O,EAAShC,E,EAAI;AAC3B,mBAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,iBAA6D;AACjEkC,yBADiE;AAEjED,0BAAWI,OAFsD,CAE9C;AAF8C,aAA7D,EAGJhC,EAHI,CAAP;AAIF;;;gCAWMiC,M,EAAQJ,I,EAAMK,O,EAASlC,E,EAAI;AAAA;;AAC/B,gBAAImC,OAAO;AACRD,+BADQ;AAERL,yBAFQ;AAGRO,wBAAS,CAACH,MAAD;AAHD,aAAX;;AAMA,mBAAO,KAAKhC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,mBAA+DwC,IAA/D,EAAqEnC,EAArE,EACHqC,IADG,CACE,UAACC,QAAD,EAAc;AACjB,sBAAK1C,aAAL,CAAmBE,GAAnB,GAAyBwC,SAASH,IAAT,CAAcrC,GAAvC,CADiB,CAC2B;AAC5C,sBAAOwC,QAAP;AACF,aAJG,CAAP;AAKF;;;oCAWUvC,G,EAAKwC,S,EAAWC,K,EAAOxC,E,EAAI;AACnC,mBAAO,KAAKC,QAAL,CAAc,OAAd,cAAiC,KAAKN,UAAtC,kBAA6DI,GAA7D,EAAoE;AACxED,oBAAKyC,SADmE;AAExEC,sBAAOA;AAFiE,aAApE,EAGJxC,EAHI,CAAP;AAIF;;;oCAQUA,E,EAAI;AACZ,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,EAAkD,IAAlD,EAAwDK,EAAxD,CAAP;AACF;;;yCAQeA,E,EAAI;AACjB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,0BAAqE,IAArE,EAA2EK,EAA3E,CAAP;AACF;;;0CASgBA,E,EAAI;AAClB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,qBAAgE,IAAhE,EAAsEK,EAAtE,CAAP;AACF;;;wCAScyC,Q,EAAUzC,E,EAAI;AAC1B,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,uBAAgE8C,QAAhE,EAA4E,IAA5E,EAAkFzC,EAAlF,CAAP;AACF;;;qCAWWD,G,EAAKW,I,EAAMgC,G,EAAK1C,E,EAAI;AAC7BU,mBAAOA,YAAUiC,UAAUjC,IAAV,CAAV,GAA8B,EAArC;AACA,mBAAO,KAAKT,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,kBAA2De,IAA3D,EAAmE;AACvEX;AADuE,aAAnE,EAEJC,EAFI,EAEA0C,GAFA,CAAP;AAGF;;;mCAUS3C,G,EAAK2C,G,EAAK1C,E,EAAI;AACrB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,cAAyD;AAC7DI;AAD6D,aAAzD,EAEJC,EAFI,EAEA0C,GAFA,CAAP;AAGF;;;8BAQI1C,E,EAAI;AACN,mBAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,aAAyD,IAAzD,EAA+DK,EAA/D,CAAP;AACF;;;mCAQSA,E,EAAI;AACX,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,aAAwD,IAAxD,EAA8DK,EAA9D,CAAP;AACF;;;sCASY4C,S,EAAWC,S,EAAW7C,E,EAAI;AAAA;;AACpC,gBAAI,OAAO6C,SAAP,KAAqB,UAAzB,EAAqC;AAClC7C,oBAAK6C,SAAL;AACAA,2BAAYD,SAAZ;AACAA,2BAAY,QAAZ;AACF;;AAED,mBAAO,KAAKE,MAAL,YAAqBF,SAArB,EACHP,IADG,CACE,UAACC,QAAD,EAAc;AACjB,mBAAIxC,MAAMwC,SAASH,IAAT,CAAcY,MAAd,CAAqBjD,GAA/B;AACA,sBAAO,OAAKkD,SAAL,CAAe;AACnBlD,0BADmB;AAEnBC,uCAAmB8C;AAFA,gBAAf,EAGJ7C,EAHI,CAAP;AAIF,aAPG,CAAP;AAQF;;;2CASiBE,O,EAASF,E,EAAI;AAC5B,mBAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,aAAyDO,OAAzD,EAAkEF,EAAlE,CAAP;AACF;;;0CAUgBG,M,EAAQD,O,EAASF,E,EAAI;AACnC,mBAAO,KAAKC,QAAL,CAAc,OAAd,cAAiC,KAAKN,UAAtC,eAA0DQ,MAA1D,EAAoED,OAApE,EAA6EF,EAA7E,CAAP;AACF;;;mCAQSA,E,EAAI;AACX,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,aAAwD,IAAxD,EAA8DK,EAA9D,CAAP;AACF;;;iCASOiD,E,EAAIjD,E,EAAI;AACb,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,eAAwDsD,EAAxD,EAA8D,IAA9D,EAAoEjD,EAApE,CAAP;AACF;;;oCASUE,O,EAASF,E,EAAI;AACrB,mBAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,aAAyDO,OAAzD,EAAkEF,EAAlE,CAAP;AACF;;;oCAUUiD,E,EAAI/C,O,EAASF,E,EAAI;AACzB,mBAAO,KAAKC,QAAL,CAAc,OAAd,cAAiC,KAAKN,UAAtC,eAA0DsD,EAA1D,EAAgE/C,OAAhE,EAAyEF,EAAzE,CAAP;AACF;;;oCASUiD,E,EAAIjD,E,EAAI;AAChB,mBAAO,KAAKC,QAAL,CAAc,QAAd,EAA2B,KAAKiD,UAAhC,eAAoDD,EAApD,EAA0D,IAA1D,EAAgEjD,EAAhE,CAAP;AACF;;;oCAUUH,M,EAAQa,I,EAAMV,E,EAAI;AAAA;;AAC1B,mBAAO,KAAKmD,MAAL,CAAYtD,MAAZ,EAAoBa,IAApB,EACH2B,IADG,CACE,UAACC,QAAD,EAAc;AACjB,mBAAMc,eAAe;AAClBlB,qDAAgCxB,IAAhC,OADkB;AAElBZ,uBAAKwC,SAASH,IAAT,CAAcrC,GAFD;AAGlBD;AAHkB,gBAArB;AAKA,sBAAO,OAAKI,QAAL,CAAc,QAAd,cAAkC,OAAKN,UAAvC,kBAA8De,IAA9D,EAAsE0C,YAAtE,EAAoFpD,EAApF,CAAP;AACF,aARG,CAAP;AASF;;;8BAUIH,M,EAAQwD,O,EAASC,O,EAAStD,E,EAAI;AAAA;;AAChC,gBAAIuD,eAAJ;AACA,mBAAO,KAAKT,MAAL,YAAqBjD,MAArB,EACHwC,IADG,CACE;AAAA,mBAASU,MAAT,QAAEZ,IAAF,CAASY,MAAT;AAAA,sBAAsB,OAAKS,OAAL,CAAgBT,OAAOjD,GAAvB,qBAAtB;AAAA,aADF,EAEHuC,IAFG,CAEE,iBAAyB;AAAA,sCAAvBF,IAAuB;AAAA,mBAAhBN,IAAgB,cAAhBA,IAAgB;AAAA,mBAAV/B,GAAU,cAAVA,GAAU;;AAC5ByD,wBAASzD,GAAT;AACA,mBAAI6B,UAAUE,KAAK4B,GAAL,CAAS,UAAC1D,GAAD,EAAS;AAC7B,sBAAIA,IAAIW,IAAJ,KAAa2C,OAAjB,EAA0B;AACvBtD,yBAAIW,IAAJ,GAAW4C,OAAX;AACF;AACD,sBAAIvD,IAAIgC,IAAJ,KAAa,MAAjB,EAAyB;AACtB,4BAAOhC,IAAID,GAAX;AACF;AACD,yBAAOC,GAAP;AACF,gBARa,CAAd;AASA,sBAAO,OAAK2D,UAAL,CAAgB/B,OAAhB,CAAP;AACF,aAdG,EAeHU,IAfG,CAeE;AAAA,mBAAQR,IAAR,SAAEM,IAAF;AAAA,sBAAkB,OAAKwB,MAAL,CAAYJ,MAAZ,EAAoB1B,KAAK/B,GAAzB,iBAA0CuD,OAA1C,gBAA0DC,OAA1D,QAAlB;AAAA,aAfF,EAgBHjB,IAhBG,CAgBE;AAAA,mBAAQsB,MAAR,SAAExB,IAAF;AAAA,sBAAoB,OAAKyB,UAAL,YAAyB/D,MAAzB,EAAmC8D,OAAO7D,GAA1C,EAA+C,IAA/C,EAAqDE,EAArD,CAApB;AAAA,aAhBF,CAAP;AAiBF;;;mCAgBSH,M,EAAQa,I,EAAME,O,EAASsB,O,EAAShC,O,EAASF,E,EAAI;AAAA;;AACpD,gBAAI,OAAOE,OAAP,KAAmB,UAAvB,EAAmC;AAChCF,oBAAKE,OAAL;AACAA,yBAAU,EAAV;AACF;AACD,gBAAI2D,WAAWnD,OAAOiC,UAAUjC,IAAV,CAAP,GAAyB,EAAxC;AACA,gBAAIoD,eAAe5D,QAAQc,MAAR,KAAmB,KAAtC;AACA,gBAAI2C,SAAS;AACV9D,6BADU;AAEVqC,+BAFU;AAGV6B,uBAAQ7D,QAAQ6D,MAHN;AAIVC,0BAAW9D,QAAQ8D,SAJT;AAKVpD,wBAASkD,eAAezC,eAAOL,MAAP,CAAcJ,OAAd,CAAf,GAAwCA;AALvC,aAAb;;AAQA,mBAAO,KAAKuC,MAAL,CAAYtD,MAAZ,EAAoBgE,QAApB,EACHxB,IADG,CACE,UAACC,QAAD,EAAc;AACjBqB,sBAAO7D,GAAP,GAAawC,SAASH,IAAT,CAAcrC,GAA3B;AACA,sBAAO,OAAKG,QAAL,CAAc,KAAd,cAA+B,OAAKN,UAApC,kBAA2DkE,QAA3D,EAAuEF,MAAvE,EAA+E3D,EAA/E,CAAP;AACF,aAJG,EAID,YAAM;AACN,sBAAO,OAAKC,QAAL,CAAc,KAAd,cAA+B,OAAKN,UAApC,kBAA2DkE,QAA3D,EAAuEF,MAAvE,EAA+E3D,EAA/E,CAAP;AACF,aANG,CAAP;AAOF;;;mCASSA,E,EAAI;AACX,mBAAO,KAAKiE,gBAAL,oBAAuC,KAAKtE,UAA5C,EAA0D,IAA1D,EAAgEK,EAAhE,CAAP;AACF;;;8BAQIA,E,EAAI;AACN,mBAAO,KAAKC,QAAL,CAAc,KAAd,qBAAsC,KAAKN,UAA3C,EAAyD,IAAzD,EAA+DK,EAA/D,CAAP;AACF;;;gCAQMA,E,EAAI;AACR,mBAAO,KAAKC,QAAL,CAAc,QAAd,qBAAyC,KAAKN,UAA9C,EAA4D,IAA5D,EAAkEK,EAAlE,CAAP;AACF;;;uCASaE,O,EAASF,E,EAAI;AACxB,mBAAO,KAAKC,QAAL,CAAc,MAAd,cAAgC,KAAKN,UAArC,gBAA4DO,OAA5D,EAAqEF,EAArE,CAAP;AACF;;;uCAUaiD,E,EAAI/C,O,EAASF,E,EAAI;AAC5B,mBAAO,KAAKC,QAAL,CAAc,OAAd,cAAiC,KAAKN,UAAtC,kBAA6DsD,EAA7D,EAAmE/C,OAAnE,EAA4EF,EAA5E,CAAP;AACF;;;sCAQYA,E,EAAI;AACd,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,gBAA2D,IAA3D,EAAiEK,EAAjE,CAAP;AACF;;;oCASUiD,E,EAAIjD,E,EAAI;AAChB,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,kBAA2DsD,EAA3D,EAAiE,IAAjE,EAAuEjD,EAAvE,CAAP;AACF;;;uCASaiD,E,EAAIjD,E,EAAI;AACnB,mBAAO,KAAKC,QAAL,CAAc,QAAd,cAAkC,KAAKN,UAAvC,kBAA8DsD,EAA9D,EAAoE,IAApE,EAA0EjD,EAA1E,CAAP;AACF;;;0CAUgBG,M,EAAQD,O,EAASF,E,EAAI;AACnC,mBAAO,KAAKC,QAAL,CAAc,KAAd,cAA+B,KAAKN,UAApC,eAAwDQ,MAAxD,aAAwED,OAAxE,EAAiFF,EAAjF,CAAP;AACF;;;;KAvtBqBkE,qB;;AA0tBzBC,UAAOC,OAAP,GAAiB7E,UAAjB","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository (after pagination)\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {}\n    * @return {Promise} - the promise for the http request\n    */\n   listAllBranches() {\n      return this._requestAllPages(`/repos/${this.__fullname}/branches`, null);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8'\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64'\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64'\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob'\n         }]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA // eslint-disable-line\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent]\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force\n      }, cb);\n   }\n\n   /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequst(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {strign} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n}\n\nmodule.exports = Repository;\n"]} //# sourceMappingURL=Repository.js.map diff --git a/dist/components/Repository.js.map b/dist/components/Repository.js.map index 7151f8a2..ba8c74af 100644 --- a/dist/components/Repository.js.map +++ b/dist/components/Repository.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb);\n }\n \n /**\n * List all the branches for the repository (after pagination)\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param\n * @return {Promise} - the promise for the http request\n */ \n listAllBranches() {\n return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * List all the branches for the repository (after pagination)\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {}\n * @return {Promise} - the promise for the http request\n */\n listAllBranches() {\n return this._requestAllPages(`/repos/${this.__fullname}/branches`, null);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8'\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64'\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64'\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob'\n }]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA // eslint-disable-line\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent]\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force\n }, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequst(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `${this.__repoPath}/hooks/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {strign} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js"} \ No newline at end of file diff --git a/lib/Repository.js b/lib/Repository.js index 6fc2d6a6..db97810c 100644 --- a/lib/Repository.js +++ b/lib/Repository.js @@ -138,17 +138,17 @@ class Repository extends Requestable { * @return {Promise} - the promise for the http request */ listBranches(cb) { - return this._request('GET', `/repos/${this.__fullname}/branches`, {per_page: 100}, cb); + return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb); } - + /** * List all the branches for the repository (after pagination) * @see https://developer.github.com/v3/repos/#list-branches - * @param + * @param {} * @return {Promise} - the promise for the http request - */ + */ listAllBranches() { - return this._requestAllPages('GET', `/repos/${this.__fullname}/branches`, null); + return this._requestAllPages(`/repos/${this.__fullname}/branches`, null); } /**