github-api/dist/components/Repository.js

'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "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; }; }();

var _Requestable2 = require('./Requestable');

var _Requestable3 = _interopRequireDefault(_Requestable2);

var _utf = require('utf8');

var _utf2 = _interopRequireDefault(_utf);

var _jsBase = require('js-base64');

var _debug = require('debug');

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"); } }

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; } /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @file
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *             Github.js is freely distributable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */

var log = (0, _debug2.default)('github:repository');

/**
 * Repository 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, (Repository.__proto__ || 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);
      }

      /**
       * Create a reference
       * @see https://developer.github.com/v3/git/refs/#create-a-reference
       * @param {Object} options - the object describing the ref
       * @param {Requestable.callback} [cb] - will receive the ref
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'createRef',
      value: function createRef(options, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/git/refs', options, cb);
      }

      /**
       * Delete a reference
       * @see https://developer.github.com/v3/git/refs/#delete-a-reference
       * @param {string} ref - the name of the ref to delte
       * @param {Requestable.callback} [cb] - will receive true if the request is successful
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'deleteRef',
      value: function deleteRef(ref, cb) {
         return this._request('DELETE', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb);
      }

      /**
       * Delete a repository
       * @see https://developer.github.com/v3/repos/#delete-a-repository
       * @param {Requestable.callback} [cb] - will receive true if the request is successful
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'deleteRepo',
      value: function deleteRepo(cb) {
         return this._request('DELETE', '/repos/' + this.__fullname, null, cb);
      }

      /**
       * List the tags on a repository
       * @see https://developer.github.com/v3/repos/#list-tags
       * @param {Requestable.callback} [cb] - will receive the tag data
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listTags',
      value: function listTags(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/tags', null, cb);
      }

      /**
       * List the open pull requests on the repository
       * @see https://developer.github.com/v3/pulls/#list-pull-requests
       * @param {Object} options - options to filter the search
       * @param {Requestable.callback} [cb] - will receive the list of PRs
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listPullRequests',
      value: function listPullRequests(options, cb) {
         options = options || {};
         return this._request('GET', '/repos/' + this.__fullname + '/pulls', options, cb);
      }

      /**
       * Get information about a specific pull request
       * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request
       * @param {number} number - the PR you wish to fetch
       * @param {Requestable.callback} [cb] - will receive the PR from the API
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getPullRequest',
      value: function getPullRequest(number, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number, null, cb);
      }

      /**
       * List the files of a specific pull request
       * @see https://developer.github.com/v3/pulls/#list-pull-requests-files
       * @param {number|string} number - the PR you wish to fetch
       * @param {Requestable.callback} [cb] - will receive the list of files from the API
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listPullRequestFiles',
      value: function listPullRequestFiles(number, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number + '/files', null, cb);
      }

      /**
       * Compare two branches/commits/repositories
       * @see https://developer.github.com/v3/repos/commits/#compare-two-commits
       * @param {string} base - the base commit
       * @param {string} head - the head commit
       * @param {Requestable.callback} cb - will receive the comparison
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'compareBranches',
      value: function compareBranches(base, head, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/compare/' + base + '...' + head, null, cb);
      }

      /**
       * List all the branches for the repository
       * @see https://developer.github.com/v3/repos/#list-branches
       * @param {Requestable.callback} cb - will receive the list of branches
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listBranches',
      value: function listBranches(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb);
      }

      /**
       * Get a raw blob from the repository
       * @see https://developer.github.com/v3/git/blobs/#get-a-blob
       * @param {string} sha - the sha of the blob to fetch
       * @param {Requestable.callback} cb - will receive the blob from the API
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getBlob',
      value: function getBlob(sha, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/git/blobs/' + sha, null, cb, 'raw');
      }

      /**
       * Get a single branch
       * @see https://developer.github.com/v3/repos/branches/#get-branch
       * @param {string} branch - the name of the branch to fetch
       * @param {Requestable.callback} cb - will receive the branch from the API
       * @returns {Promise} - the promise for the http request
       */

   }, {
      key: 'getBranch',
      value: function getBranch(branch, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/branches/' + branch, null, cb);
      }

      /**
       * Get a commit from the repository
       * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit
       * @param {string} sha - the sha for the commit to fetch
       * @param {Requestable.callback} cb - will receive the commit data
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getCommit',
      value: function getCommit(sha, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/git/commits/' + sha, null, cb);
      }

      /**
       * List the commits on a repository, optionally filtering by path, author or time range
       * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository
       * @param {Object} [options] - the filtering options for commits
       * @param {string} [options.sha] - the SHA or branch to start from
       * @param {string} [options.path] - the path to search on
       * @param {string} [options.author] - the commit author
       * @param {(Date|string)} [options.since] - only commits after this date will be returned
       * @param {(Date|string)} [options.until] - only commits before this date will be returned
       * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listCommits',
      value: function listCommits(options, cb) {
         options = options || {};
         if (typeof options === 'function') {
            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);
      }

      /**
       * List the commits on a pull request
       * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository
       * @param {number|string} number - the number of the pull request to list the commits
       * @param {Object} [options] - the filtering options for commits
       * @param {Requestable.callback} [cb] - will receive the commits information
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listCommitsOnPR',
      value: function listCommitsOnPR(number, options, cb) {
         options = options || {};
         if (typeof options === 'function') {
            cb = options;
            options = {};
         }
         return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number + '/commits', options, cb);
      }

      /**
       * Gets a single commit information for a repository
       * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit
       * @param {string} ref - the reference for the commit-ish
       * @param {Requestable.callback} cb - will receive the commit information
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getSingleCommit',
      value: function getSingleCommit(ref, cb) {
         ref = ref || '';
         return this._request('GET', '/repos/' + this.__fullname + '/commits/' + ref, null, cb);
      }

      /**
       * Get tha sha for a particular object in the repository. This is a convenience function
       * @see https://developer.github.com/v3/repos/contents/#get-contents
       * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted
       * @param {string} path - the path of the file or directory
       * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getSha',
      value: function getSha(branch, path, cb) {
         branch = branch ? '?ref=' + branch : '';
         return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path + branch, null, cb);
      }

      /**
       * List the commit statuses for a particular sha, branch, or tag
       * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
       * @param {string} sha - the sha, branch, or tag to get statuses for
       * @param {Requestable.callback} cb - will receive the list of statuses
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listStatuses',
      value: function listStatuses(sha, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/commits/' + sha + '/statuses', null, cb);
      }

      /**
       * Get the combined view of commit statuses for a particular sha, branch, or tag
       * @see https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
       * @param {string} sha - the sha, branch, or tag to get the combined status for
       * @param {Requestable.callback} cb - will receive the combined status
       * @returns {Promise} - the promise for the http request
       */

   }, {
      key: 'getCombinedStatus',
      value: function getCombinedStatus(sha, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/commits/' + sha + '/status', null, cb);
      }

      /**
       * Get a description of a git tree
       * @see https://developer.github.com/v3/git/trees/#get-a-tree
       * @param {string} treeSHA - the SHA of the tree to fetch
       * @param {Requestable.callback} cb - will receive the callback data
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getTree',
      value: function getTree(treeSHA, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/git/trees/' + treeSHA, null, cb);
      }

      /**
       * Create a blob
       * @see https://developer.github.com/v3/git/blobs/#create-a-blob
       * @param {(string|Buffer|Blob)} content - the content to add to the repository
       * @param {Requestable.callback} cb - will receive the details of the created blob
       * @return {Promise} - the promise for the http request
       */

   }, {
      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);
      }

      /**
       * Get the object that represents the provided content
       * @param {string|Buffer|Blob} content - the content to send to the server
       * @return {Object} the representation of `content` for the GitHub API
       */

   }, {
      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)');
         }
      }

      /**
       * Update a tree in Git
       * @see https://developer.github.com/v3/git/trees/#create-a-tree
       * @param {string} baseTreeSHA - the SHA of the tree to update
       * @param {string} path - the path for the new file
       * @param {string} blobSHA - the SHA for the blob to put at `path`
       * @param {Requestable.callback} cb - will receive the new tree that is created
       * @return {Promise} - the promise for the http request
       * @deprecated use {@link Repository#createTree} instead
       */

   }, {
      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);
      }

      /**
       * Create a new tree in git
       * @see https://developer.github.com/v3/git/trees/#create-a-tree
       * @param {Object} tree - the tree to create
       * @param {string} baseSHA - the root sha of the tree
       * @param {Requestable.callback} cb - will receive the new tree that is created
       * @return {Promise} - the promise for the http request
       */

   }, {
      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 camelcase
         }, cb);
      }

      /**
       * Add a commit to the repository
       * @see https://developer.github.com/v3/git/commits/#create-a-commit
       * @param {string} parent - the SHA of the parent commit
       * @param {string} tree - the SHA of the tree for this commit
       * @param {string} message - the commit message
       * @param {Object} [options] - commit options
       * @param {Object} [options.author] - the author of the commit
       * @param {Object} [options.commiter] - the committer
       * @param {Requestable.callback} cb - will receive the commit that is created
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'commit',
      value: function commit(parent, tree, message, options, cb) {
         var _this2 = this;

         if (typeof options === 'function') {
            cb = options;
            options = {};
         }

         var data = {
            message: message,
            tree: tree,
            parents: [parent]
         };

         data = Object.assign({}, options, data);

         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;
         });
      }

      /**
       * Update a ref
       * @see https://developer.github.com/v3/git/refs/#update-a-reference
       * @param {string} ref - the ref to update
       * @param {string} commitSHA - the SHA to point the reference to
       * @param {boolean} force - indicates whether to force or ensure a fast-forward update
       * @param {Requestable.callback} cb - will receive the updated ref back
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'updateHead',
      value: function updateHead(ref, commitSHA, force, cb) {
         return this._request('PATCH', '/repos/' + this.__fullname + '/git/refs/' + ref, {
            sha: commitSHA,
            force: force
         }, cb);
      }

      /**
       * Update commit status
       * @see https://developer.github.com/v3/repos/statuses/
       * @param {string} commitSHA - the SHA of the commit that should be updated
       * @param {object} options - Commit status parameters
       * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.
       * @param {string} [options.target_url] - The target URL to associate with this status.
       * @param {string} [options.description] - A short description of the status.
       * @param {string} [options.context] - A string label to differentiate this status among CI systems.
       * @param {Requestable.callback} cb - will receive the updated commit back
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'updateStatus',
      value: function updateStatus(commitSHA, options, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/statuses/' + commitSHA, options, cb);
      }

      /**
       * Update repository information
       * @see https://developer.github.com/v3/repos/#edit
       * @param {object} options - New parameters that will be set to the repository
       * @param {string} options.name - Name of the repository
       * @param {string} [options.description] - A short description of the repository
       * @param {string} [options.homepage] - A URL with more information about the repository
       * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.
       * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.
       * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.
       * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.
       * @param {string} [options.default_branch] - Updates the default branch for this repository.
       * @param {Requestable.callback} cb - will receive the updated repository back
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'updateRepository',
      value: function updateRepository(options, cb) {
         return this._request('PATCH', '/repos/' + this.__fullname, options, cb);
      }

      /**
        * Get information about the repository
        * @see https://developer.github.com/v3/repos/#get
        * @param {Requestable.callback} cb - will receive the information about the repository
        * @return {Promise} - the promise for the http request
        */

   }, {
      key: 'getDetails',
      value: function getDetails(cb) {
         return this._request('GET', '/repos/' + this.__fullname, null, cb);
      }

      /**
       * List the contributors to the repository
       * @see https://developer.github.com/v3/repos/#list-contributors
       * @param {Requestable.callback} cb - will receive the list of contributors
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getContributors',
      value: function getContributors(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/contributors', null, cb);
      }

      /**
       * List the contributor stats to the repository
       * @see https://developer.github.com/v3/repos/#list-contributors
       * @param {Requestable.callback} cb - will receive the list of contributors
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getContributorStats',
      value: function getContributorStats(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/stats/contributors', null, cb);
      }

      /**
       * List the users who are collaborators on the repository. The currently authenticated user must have
       * push access to use this method
       * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators
       * @param {Requestable.callback} cb - will receive the list of collaborators
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getCollaborators',
      value: function getCollaborators(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/collaborators', null, cb);
      }

      /**
       * Check if a user is a collaborator on the repository
       * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator
       * @param {string} username - the user to check
       * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not
       * @return {Promise} - the promise for the http request {Boolean} [description]
       */

   }, {
      key: 'isCollaborator',
      value: function isCollaborator(username, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/collaborators/' + username, null, cb);
      }

      /**
       * Get the contents of a repository
       * @see https://developer.github.com/v3/repos/contents/#get-contents
       * @param {string} ref - the ref to check
       * @param {string} path - the path containing the content to fetch
       * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format
       * @param {Requestable.callback} cb - will receive the fetched data
       * @return {Promise} - the promise for the http request
       */

   }, {
      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);
      }

      /**
       * Get the README of a repository
       * @see https://developer.github.com/v3/repos/contents/#get-the-readme
       * @param {string} ref - the ref to check
       * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format
       * @param {Requestable.callback} cb - will receive the fetched data
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getReadme',
      value: function getReadme(ref, raw, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/readme', {
            ref: ref
         }, cb, raw);
      }

      /**
       * Fork a repository
       * @see https://developer.github.com/v3/repos/forks/#create-a-fork
       * @param {Requestable.callback} cb - will receive the information about the newly created fork
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'fork',
      value: function fork(cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/forks', null, cb);
      }

      /**
       * Fork a repository to an organization
       * @see https://developer.github.com/v3/repos/forks/#create-a-fork
       * @param {String} org - organization where you'd like to create the fork.
       * @param {Requestable.callback} cb - will receive the information about the newly created fork
       * @return {Promise} - the promise for the http request
       *
       */

   }, {
      key: 'forkToOrg',
      value: function forkToOrg(org, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/forks?organization=' + org, null, cb);
      }

      /**
       * List a repository's forks
       * @see https://developer.github.com/v3/repos/forks/#list-forks
       * @param {Requestable.callback} cb - will receive the list of repositories forked from this one
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listForks',
      value: function listForks(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/forks', null, cb);
      }

      /**
       * Create a new branch from an existing branch.
       * @param {string} [oldBranch=master] - the name of the existing branch
       * @param {string} newBranch - the name of the new branch
       * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch
       * @return {Promise} - the promise for the http request
       */

   }, {
      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);
         });
      }

      /**
       * Create a new pull request
       * @see https://developer.github.com/v3/pulls/#create-a-pull-request
       * @param {Object} options - the pull request description
       * @param {Requestable.callback} cb - will receive the new pull request
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'createPullRequest',
      value: function createPullRequest(options, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/pulls', options, cb);
      }

      /**
       * Update a pull request
       * @see https://developer.github.com/v3/pulls/#update-a-pull-request
       * @param {number|string} number - the number of the pull request to update
       * @param {Object} options - the pull request description
       * @param {Requestable.callback} [cb] - will receive the pull request information
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'updatePullRequest',
      value: function updatePullRequest(number, options, cb) {
         return this._request('PATCH', '/repos/' + this.__fullname + '/pulls/' + number, options, cb);
      }

      /**
       * List the hooks for the repository
       * @see https://developer.github.com/v3/repos/hooks/#list-hooks
       * @param {Requestable.callback} cb - will receive the list of hooks
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listHooks',
      value: function listHooks(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/hooks', null, cb);
      }

      /**
       * Get a hook for the repository
       * @see https://developer.github.com/v3/repos/hooks/#get-single-hook
       * @param {number} id - the id of the webook
       * @param {Requestable.callback} cb - will receive the details of the webook
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getHook',
      value: function getHook(id, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/hooks/' + id, null, cb);
      }

      /**
       * Add a new hook to the repository
       * @see https://developer.github.com/v3/repos/hooks/#create-a-hook
       * @param {Object} options - the configuration describing the new hook
       * @param {Requestable.callback} cb - will receive the new webhook
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'createHook',
      value: function createHook(options, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/hooks', options, cb);
      }

      /**
       * Edit an existing webhook
       * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook
       * @param {number} id - the id of the webhook
       * @param {Object} options - the new description of the webhook
       * @param {Requestable.callback} cb - will receive the updated webhook
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'updateHook',
      value: function updateHook(id, options, cb) {
         return this._request('PATCH', '/repos/' + this.__fullname + '/hooks/' + id, options, cb);
      }

      /**
       * Delete a webhook
       * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook
       * @param {number} id - the id of the webhook to be deleted
       * @param {Requestable.callback} cb - will receive true if the call is successful
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'deleteHook',
      value: function deleteHook(id, cb) {
         return this._request('DELETE', '/repos/' + this.__fullname + '/hooks/' + id, null, cb);
      }

      /**
       * List the deploy keys for the repository
       * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys
       * @param {Requestable.callback} cb - will receive the list of deploy keys
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listKeys',
      value: function listKeys(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/keys', null, cb);
      }

      /**
       * Get a deploy key for the repository
       * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key
       * @param {number} id - the id of the deploy key
       * @param {Requestable.callback} cb - will receive the details of the deploy key
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getKey',
      value: function getKey(id, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/keys/' + id, null, cb);
      }

      /**
       * Add a new deploy key to the repository
       * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key
       * @param {Object} options - the configuration describing the new deploy key
       * @param {Requestable.callback} cb - will receive the new deploy key
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'createKey',
      value: function createKey(options, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/keys', options, cb);
      }

      /**
       * Delete a deploy key
       * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key
       * @param {number} id - the id of the deploy key to be deleted
       * @param {Requestable.callback} cb - will receive true if the call is successful
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'deleteKey',
      value: function deleteKey(id, cb) {
         return this._request('DELETE', '/repos/' + this.__fullname + '/keys/' + id, null, cb);
      }

      /**
       * Delete a file from a branch
       * @see https://developer.github.com/v3/repos/contents/#delete-a-file
       * @param {string} branch - the branch to delete from, or the default branch if not specified
       * @param {string} path - the path of the file to remove
       * @param {Requestable.callback} cb - will receive the commit in which the delete occurred
       * @return {Promise} - the promise for the http request
       */

   }, {
      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);
         });
      }

      /**
       * Change all references in a repo from oldPath to new_path
       * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified
       * @param {string} oldPath - original path
       * @param {string} newPath - new reference path
       * @param {Requestable.callback} cb - will receive the commit in which the move occurred
       * @return {Promise} - the promise for the http request
       */

   }, {
      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,
                tree = _ref2$data.tree,
                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);
         });
      }

      /**
       * Write a file to the repository
       * @see https://developer.github.com/v3/repos/contents/#update-a-file
       * @param {string} branch - the name of the branch
       * @param {string} path - the path for the file
       * @param {string} content - the contents of the file
       * @param {string} message - the commit message
       * @param {Object} [options] - commit options
       * @param {Object} [options.author] - the author of the commit
       * @param {Object} [options.commiter] - the committer
       * @param {boolean} [options.encode] - true if the content should be base64 encoded
       * @param {Requestable.callback} cb - will receive the new commit
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'writeFile',
      value: function writeFile(branch, path, content, message, options, cb) {
         var _this6 = this;

         options = options || {};
         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);
         });
      }

      /**
       * Check if a repository is starred by you
       * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository
       * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository
       *                                  is not starred
       * @return {Promise} - the promise for the http request {Boolean} [description]
       */

   }, {
      key: 'isStarred',
      value: function isStarred(cb) {
         return this._request204or404('/user/starred/' + this.__fullname, null, cb);
      }

      /**
       * Star a repository
       * @see https://developer.github.com/v3/activity/starring/#star-a-repository
       * @param {Requestable.callback} cb - will receive true if the repository is starred
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'star',
      value: function star(cb) {
         return this._request('PUT', '/user/starred/' + this.__fullname, null, cb);
      }

      /**
       * Unstar a repository
       * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository
       * @param {Requestable.callback} cb - will receive true if the repository is unstarred
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'unstar',
      value: function unstar(cb) {
         return this._request('DELETE', '/user/starred/' + this.__fullname, null, cb);
      }

      /**
       * Create a new release
       * @see https://developer.github.com/v3/repos/releases/#create-a-release
       * @param {Object} options - the description of the release
       * @param {Requestable.callback} cb - will receive the newly created release
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'createRelease',
      value: function createRelease(options, cb) {
         return this._request('POST', '/repos/' + this.__fullname + '/releases', options, cb);
      }

      /**
       * Edit a release
       * @see https://developer.github.com/v3/repos/releases/#edit-a-release
       * @param {string} id - the id of the release
       * @param {Object} options - the description of the release
       * @param {Requestable.callback} cb - will receive the modified release
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'updateRelease',
      value: function updateRelease(id, options, cb) {
         return this._request('PATCH', '/repos/' + this.__fullname + '/releases/' + id, options, cb);
      }

      /**
       * Get information about all releases
       * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository
       * @param {Requestable.callback} cb - will receive the release information
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listReleases',
      value: function listReleases(cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/releases', null, cb);
      }

      /**
       * Get information about a release
       * @see https://developer.github.com/v3/repos/releases/#get-a-single-release
       * @param {string} id - the id of the release
       * @param {Requestable.callback} cb - will receive the release information
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'getRelease',
      value: function getRelease(id, cb) {
         return this._request('GET', '/repos/' + this.__fullname + '/releases/' + id, null, cb);
      }

      /**
       * Delete a release
       * @see https://developer.github.com/v3/repos/releases/#delete-a-release
       * @param {string} id - the release to be deleted
       * @param {Requestable.callback} cb - will receive true if the operation is successful
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'deleteRelease',
      value: function deleteRelease(id, cb) {
         return this._request('DELETE', '/repos/' + this.__fullname + '/releases/' + id, null, cb);
      }

      /**
       * Merge a pull request
       * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button
       * @param {number|string} number - the number of the pull request to merge
       * @param {Object} options - the merge options for the pull request
       * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'mergePullRequest',
      value: function mergePullRequest(number, options, cb) {
         return this._request('PUT', '/repos/' + this.__fullname + '/pulls/' + number + '/merge', options, cb);
      }

      /**
       * Get information about all projects
       * @see https://developer.github.com/v3/projects/#list-repository-projects
       * @param {Requestable.callback} [cb] - will receive the list of projects
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'listProjects',
      value: function listProjects(cb) {
         return this._requestAllPages('/repos/' + this.__fullname + '/projects', { AcceptHeader: 'inertia-preview' }, cb);
      }

      /**
       * Create a new project
       * @see https://developer.github.com/v3/projects/#create-a-repository-project
       * @param {Object} options - the description of the project
       * @param {Requestable.callback} cb - will receive the newly created project
       * @return {Promise} - the promise for the http request
       */

   }, {
      key: 'createProject',
      value: function createProject(options, cb) {
         options = options || {};
         options.AcceptHeader = 'inertia-preview';
         return this._request('POST', '/repos/' + this.__fullname + '/projects', options, cb);
      }
   }]);

   return Repository;
}(_Requestable3.default);

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","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","Object","assign","then","response","commitSHA","force","username","raw","encodeURI","org","oldBranch","newBranch","getRef","object","createRef","id","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","_requestAllPages","AcceptHeader","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 * Repository 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 single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\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      if (typeof options === 'function') {\n         cb = options;\n         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    * List the commits on a pull request\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {number|string} number - the number of the pull request to list the commits\n    * @param {Object} [options] - the filtering options for commits\n    * @param {Requestable.callback} [cb] - will receive the commits information\n    * @return {Promise} - the promise for the http request\n    */\n   listCommitsOnPR(number, options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/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 the combined view of commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get the combined status for\n    * @param {Requestable.callback} cb - will receive the combined status\n    * @returns {Promise} - the promise for the http request\n    */\n   getCombinedStatus(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/status`, 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 camelcase\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 {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\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, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      data = Object.assign({}, options, data);\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    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, 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}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats 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   getContributorStats(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    * Fork a repository to an organization\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {String} org - organization where you'd like to create the 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    */\n   forkToOrg(org, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks?organization=${org}`, 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   updatePullRequest(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', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key 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   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${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      options = options || {};\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 {string} 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   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n"]}
//# sourceMappingURL=Repository.js.map