Adds the upload asset release api

Here's a first pass at adding this feature. Please tell me if you'd
like it implemented a different way. Of course I like it as is :P
but some things to consider

*   Content-Type

    Currently I set the content type automatically based on the name
    you pass in. This is a little magic as it assumes there's both
    a `filePath` and `name` field.

    It could be required to be set by the user as in

        github.releases.uploadAsset({
            owner: owner,
            id: releaseId,
            headers: {
               "content-type": "application/zip",
            }
            ...

    Similarly the size could be manually set there. But, since, based
    on the current API there's no way for us to upload the file (we
    don't get the request object back, and we can't just pass the
    data (it's arguably too big. Could be 100s of meg, more than
    fits in node's memory space), it seems like we should lookup
    the size and stream the file as it does now?

*   Timeout

    Wasn't sure what to do about that. Timeouts don't seem appropriate
    for uploading giant files or at least can't easily be a global
    setting.

Anyway, if you don't like this patch hopefully you can suggest a way
you'd prefer it.

Author: greggman

README.md

@@ -147,7 +147,7 @@ github.authorization.create({
 * Search: 100%
 * Markdown: 100%
 * Rate Limit: 100%
-* Releases: 90%
+* Releases: 100%
 * Gitignore: 100%
 * Meta: 100%
 * Emojis: 100%

api/v3.0.0/releases.js

@@ -325,6 +325,49 @@ var releases = module.exports = {
         });
     };
 
+    /** section: github
+     *  releases#uploadAsset(msg, callback) -> null
+     *      - msg (Object): Object that contains the parameters and their values to be sent to the server.
+     *      - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
+     *
+     *  ##### Params on the `msg` object:
+     *
+     *  - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
+     *  - owner (String): Required. 
+     *  - id (Number): Required. 
+     *  - repo (String): Required. 
+     *  - name (String): Required. the file name of the asset
+     **/
+    this.uploadAsset = function(msg, block, callback) {
+        var self = this;
+        this.client.httpSend(msg, block, function(err, res) {
+            if (err)
+                return self.sendError(err, null, msg, callback);
+
+            var ret;
+            try {
+                ret = res.data && JSON.parse(res.data);
+            }
+            catch (ex) {
+                if (callback)
+                    callback(new error.InternalServerError(ex.message), res);
+                return;
+            }
+
+            if (!ret)
+                ret = {};
+            if (!ret.meta)
+                ret.meta = {};
+            ["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
+                if (res.headers[header])
+                    ret.meta[header] = res.headers[header];
+            });
+
+            if (callback)
+                callback(null, ret);
+        });
+    };
+
     /** section: github
      *  releases#editAsset(msg, callback) -> null
      *      - msg (Object): Object that contains the parameters and their values to be sent to the server.

api/v3.0.0/releasesTest.js

@@ -11,6 +11,8 @@
 
 var Assert = require("assert");
 var Client = require("./../../index");
+var fs = require("fs");
+var mime = require("mime");
 
 describe("[releases]", function() {
     var client;
@@ -20,6 +22,8 @@ describe("[releases]", function() {
     var repo  = "test";
     var haveWriteAccess = true;       // set to false if the authenticated person below does not have write access to the repo above
     var releaseIdWithAsset = 393621;  // Some release id from the repo above that has at least 1 asset.
+    var filePathToUpload = __filename;
+    var fileSizeToUpload = fs.statSync(filePathToUpload).size;
 
     var releaseId;      // release id found when listing releases. Used for get release
     var newReleaseId;   // release id created when creating release, used for edit and delete release
@@ -190,22 +194,48 @@ describe("[releases]", function() {
         );
     });
 
+    it("should successfully execute POST /repos/:owner/:repo/releases/:id/assets (uploadAsset)",  function(next) {
+        var name = "somenameornot.zip";
+        client.releases.uploadAsset(
+            {
+                owner: owner,
+                id: releaseIdWithAsset,
+                repo: repo,
+                name: name,
+                filePath: filePathToUpload
+            },
+            function(err, res) {
+                Assert.equal(err, null);
+                Assert.equal(res.content_type, mime.lookup(name));  // matches extension of name, not filePath
+                Assert.equal(res.state, "uploaded");
+                Assert.equal(res.size, fileSizeToUpload);
+                Assert.equal(res.name, name);
+                newAssetId = res.id;
+                next();
+            }
+        );
+    });
+
     it("should successfully execute PATCH /repos/:owner/:repo/releases/assets/:id (editAsset)",  function(next) {
         if (!newAssetId) {
             next();
             return;
         }
+        var newName = "somenewname.zip";
         client.releases.editAsset(
             {
                 owner: owner,
-                id: "Number",
+                id: newAssetId,
                 repo: repo,
-                name: "String",
-                label: "String"
+                name: newName,
+                label: "foo"
             },
             function(err, res) {
                 Assert.equal(err, null);
-                // other assertions go here
+                Assert.equal(res.state, "uploaded");
+                Assert.equal(res.size, fileSizeToUpload);
+                Assert.equal(res.name, newName);
+                Assert.equal(res.label, "foo");
                 next();
             }
         );
@@ -219,7 +249,7 @@ describe("[releases]", function() {
         client.releases.deleteAsset(
             {
                 owner: owner,
-                id: "Number",
+                id: newAssetId,
                 repo: repo
             },
             function(err, res) {

api/v3.0.0/routes.json

@@ -3452,6 +3452,37 @@
                 "$repo": null
             }
         },
+        "upload-asset": {
+            "url": "/repos/:owner/:repo/releases/:id/assets",
+            "method": "POST",
+            "host": "uploads.github.com",
+            "hasFileBody": true,
+            "timeout": 0,
+            "params": {
+                "owner": {
+                    "type": "String",
+                    "required": true,
+                    "validation": "",
+                    "invalidmsg": "",
+                    "description": ""
+                },
+                "id": {
+                    "type": "Number",
+                    "required": true,
+                    "validation": "",
+                    "invalidmsg": "",
+                    "description": ""
+                },
+                "$repo": null,
+                "name": {
+                    "type": "String",
+                    "required": true,
+                    "validation": "",
+                    "invalidmsg": "",
+                    "description": "the file name of the asset"
+                }
+            }
+        },
         "edit-asset": {
             "url": "/repos/:owner/:repo/releases/assets/:id",
             "method": "PATCH",

index.js

@@ -1,6 +1,8 @@
 "use strict";
 
 var error = require("./error");
+var fs = require("fs");
+var mime = require("mime");
 var Util = require("./util");
 var Url = require("url");
 
@@ -645,7 +647,8 @@ var Client = module.exports = function(config) {
     this.httpSend = function(msg, block, callback) {
         var self = this;
         var method = block.method.toLowerCase();
-        var hasBody = ("head|get|delete".indexOf(method) === -1);
+        var hasFileBody = block.hasFileBody;
+        var hasBody = !hasFileBody && ("head|get|delete".indexOf(method) === -1);
         var format = hasBody && this.constants.requestFormat
             ? this.constants.requestFormat
             : "query";
@@ -655,9 +658,8 @@ var Client = module.exports = function(config) {
 
         var path = url;
         var protocol = this.config.protocol || this.constants.protocol || "http";
-        var host = this.config.host || this.constants.host;
+        var host = block.host || this.config.host || this.constants.host;
         var port = this.config.port || this.constants.port || (protocol == "https" ? 443 : 80);
-
         var proxyUrl;
         if (this.config.proxy !== undefined) {
             proxyUrl = this.config.proxy;
@@ -722,6 +724,14 @@ var Client = module.exports = function(config) {
             }
         }
 
+        function callCallback(err, result) {
+            if (callback) {
+                var cb = callback;
+                callback = undefined;
+                cb(err, result);
+            }
+        }
+
         function addCustomHeaders(customHeaders) {
             Object.keys(customHeaders).forEach(function(header) {
                 var headerLC = header.toLowerCase();
@@ -752,66 +762,74 @@ var Client = module.exports = function(config) {
         if (this.debug)
             console.log("REQUEST: ", options);
 
-        var callbackCalled = false
-
-        var req = require(protocol).request(options, function(res) {
-            if (self.debug) {
-                console.log("STATUS: " + res.statusCode);
-                console.log("HEADERS: " + JSON.stringify(res.headers));
-            }
-            res.setEncoding("utf8");
-            var data = "";
-            res.on("data", function(chunk) {
-                data += chunk;
-            });
-            res.on("error", function(err) {
-                if (!callbackCalled) {
-                   callbackCalled = true;
-                   callback(err);
+        function httpSendRequest() {
+            var req = require(protocol).request(options, function(res) {
+                if (self.debug) {
+                    console.log("STATUS: " + res.statusCode);
+                    console.log("HEADERS: " + JSON.stringify(res.headers));
                 }
+                res.setEncoding("utf8");
+                var data = "";
+                res.on("data", function(chunk) {
+                    data += chunk;
+                });
+                res.on("error", function(err) {
+                    callCallback(err);
+                });
+                res.on("end", function() {
+                    if (res.statusCode >= 400 && res.statusCode < 600 || res.statusCode < 10) {
+                        callCallback(new error.HttpError(data, res.statusCode));
+                    } else {
+                        res.data = data;
+                        callCallback(null, res);
+                    }
+                });
             });
-            res.on("end", function() {
-                if (callbackCalled)
-                    return;
 
-                callbackCalled = true;
-                if (res.statusCode >= 400 && res.statusCode < 600 || res.statusCode < 10) {
-                    callback(new error.HttpError(data, res.statusCode));
-                } else {
-                    res.data = data;
-                    callback(null, res);
-                }
+            var timeout = (block.timeout !== undefined) ? block.timeout : self.config.timeout;
+            if (timeout) {
+                req.setTimeout(timeout);
+            }
+
+            req.on("error", function(e) {
+                if (self.debug)
+                    console.log("problem with request: " + e.message);
+                callCallback(e.message);
             });
-        });
 
-        if (this.config.timeout) {
-            req.setTimeout(this.config.timeout);
-        }
+            req.on("timeout", function() {
+                if (self.debug)
+                    console.log("problem with request: timed out");
+                callCallback(new error.GatewayTimeout());
+            });
 
-        req.on("error", function(e) {
-            if (self.debug)
-                console.log("problem with request: " + e.message);
-            if (!callbackCalled) {
-                callbackCalled = true;
-                callback(e.message);
+            // write data to request body
+            if (hasBody && query.length) {
+                if (self.debug)
+                    console.log("REQUEST BODY: " + query + "\n");
+                req.write(query + "\n");
             }
-        });
 
-        req.on("timeout", function() {
-            if (self.debug)
-                console.log("problem with request: timed out");
-            if (!callbackCalled) {
-                callbackCalled = true;
-                callback(new error.GatewayTimeout());
+            if (block.hasFileBody) {
+              var stream = fs.createReadStream(msg.filePath);
+              stream.pipe(req);
+            } else {
+              req.end();
             }
-        });
+        };
 
-        // write data to request body
-        if (hasBody && query.length) {
-            if (self.debug)
-                console.log("REQUEST BODY: " + query + "\n");
-            req.write(query + "\n");
+        if (hasFileBody) {
+            fs.stat(msg.filePath, function(err, stat) {
+                if (err) {
+                    callCallback(err);
+                } else {
+                    headers["content-length"] = stat.size;
+                    headers["content-type"] = mime.lookup(msg.name);
+                    httpSendRequest();
+                }
+            });
+        } else {
+            httpSendRequest();
         }
-        req.end();
     };
 }).call(Client.prototype);

package.json

@@ -15,6 +15,9 @@
     "engine" : {
         "node": ">=0.4.0"
     },
+    "dependencies": {
+      "mime": "^1.2.11"
+    },
     "devDependencies": {
         "oauth": "~0.9.7",
         "optimist": "~0.6.0",