Update go-octokit.

Godeps/Godeps.json

@@ -36,7 +36,7 @@
 		{
 			"ImportPath": "github.com/jingweno/go-octokit/octokit",
 			"Comment": "v0.4.0-41-g85bc6b5",
-			"Rev": "85bc6b536f8e8cb24d4db262e4dfea3d7d2d8138"
+			"Rev": "74f0495a72d8a2dfce059ebf718fd60dd3800f41"
 		},
 		{
 			"ImportPath": "github.com/jtacoma/uritemplates",

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/client.go

@@ -5,6 +5,7 @@ import (
 	"github.com/lostisland/go-sawyer/hypermedia"
 	"net/http"
 	"net/url"
+	"os"
 )
 
 func NewClient(authMethod AuthMethod) *Client {
@@ -24,21 +25,11 @@ type Client struct {
 }
 
 func (c *Client) NewRequest(urlStr string) (req *Request, err error) {
-	sawyerReq, err := c.sawyerClient.NewRequest(urlStr)
+	sawyerReq, err := c.newSawyerRequest(urlStr)
 	if err != nil {
 		return
 	}
 
-	sawyerReq.Header.Add("Accept", defaultMediaType)
-	sawyerReq.Header.Add("User-Agent", c.UserAgent)
-	if c.AuthMethod != nil {
-		sawyerReq.Header.Add("Authorization", c.AuthMethod.String())
-	}
-
-	if basicAuth, ok := c.AuthMethod.(BasicAuth); ok && basicAuth.OneTimePassword != "" {
-		sawyerReq.Header.Add("X-GitHub-OTP", basicAuth.OneTimePassword)
-	}
-
 	req = &Request{sawyerReq: sawyerReq}
 	return
 }
@@ -79,6 +70,43 @@ func (c *Client) patch(url *url.URL, input interface{}, output interface{}) (res
 	})
 }
 
+func (c *Client) upload(uploadUrl *url.URL, asset *os.File, contentType string) (result *Result) {
+	req, err := c.newSawyerRequest(uploadUrl.String())
+	if err != nil {
+		result = newResult(nil, err)
+		return
+	}
+
+	fi, err := asset.Stat()
+	if err != nil {
+		result = newResult(nil, err)
+		return
+	}
+
+	req.Header.Add("Content-Type", contentType)
+	req.ContentLength = fi.Size()
+
+	req.Body = asset
+	sawyerResp := req.Post()
+
+	resp, err := NewResponse(sawyerResp)
+	return newResult(resp, err)
+}
+
+func (c *Client) newSawyerRequest(urlStr string) (sawyerReq *sawyer.Request, err error) {
+	sawyerReq, err = c.sawyerClient.NewRequest(urlStr)
+	if err != nil {
+		return
+	}
+
+	sawyerReq.Header.Add("Accept", defaultMediaType)
+	sawyerReq.Header.Add("User-Agent", c.UserAgent)
+
+	c.addAuthenticationHeaders(sawyerReq.Header)
+
+	return
+}
+
 func sendRequest(c *Client, url *url.URL, fn func(r *Request) (*Response, error)) (result *Result) {
 	req, err := c.NewRequest(url.String())
 	if err != nil {
@@ -91,3 +119,13 @@ func sendRequest(c *Client, url *url.URL, fn func(r *Request) (*Response, error)
 
 	return
 }
+
+func (c *Client) addAuthenticationHeaders(header http.Header) {
+	if c.AuthMethod != nil {
+		header.Add("Authorization", c.AuthMethod.String())
+	}
+
+	if basicAuth, ok := c.AuthMethod.(BasicAuth); ok && basicAuth.OneTimePassword != "" {
+		header.Add("X-GitHub-OTP", basicAuth.OneTimePassword)
+	}
+}

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/octokit_test.go

@@ -59,6 +59,10 @@ func respondWithJSON(w http.ResponseWriter, s string) {
 	respondWith(w, s)
 }
 
+func respondWithStatus(w http.ResponseWriter, statusCode int) {
+	w.WriteHeader(statusCode)
+}
+
 func respondWith(w http.ResponseWriter, s string) {
 	fmt.Fprint(w, s)
 }

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/releases.go

@@ -17,7 +17,7 @@ type Release struct {
 	URL             string     `json:"url,omitempty"`
 	HTMLURL         string     `json:"html_url,omitempty"`
 	AssetsURL       string     `json:"assets_url,omitempty"`
-	UploadURL       string     `json:"upload_url,omitempty"`
+	UploadURL       Hyperlink  `json:"upload_url,omitempty"`
 	TagName         string     `json:"tag_name,omitempty"`
 	TargetCommitish string     `json:"target_commitish,omitempty"`
 	Name            string     `json:"name,omitempty"`

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/releases_test.go

@@ -32,7 +32,7 @@ func TestReleasesService_All(t *testing.T) {
 	assert.Equal(t, "* Windows works!: https://github.com/jingweno/gh/commit/6cb80cb09fd9f624a64d85438157955751a9ac70", firstRelease.Body)
 	assert.Equal(t, "https://api.github.com/repos/jingweno/gh/releases/50013", firstRelease.URL)
 	assert.Equal(t, "https://api.github.com/repos/jingweno/gh/releases/50013/assets", firstRelease.AssetsURL)
-	assert.Equal(t, "https://uploads.github.com/repos/jingweno/gh/releases/50013/assets{?name}", firstRelease.UploadURL)
+	assert.Equal(t, "https://uploads.github.com/repos/jingweno/gh/releases/50013/assets{?name}", string(firstRelease.UploadURL))
 	assert.Equal(t, "https://github.com/jingweno/gh/releases/v0.23.0", firstRelease.HTMLURL)
 	assert.Equal(t, "2013-09-23 00:59:10 +0000 UTC", firstRelease.CreatedAt.String())
 	assert.Equal(t, "2013-09-23 01:07:56 +0000 UTC", firstRelease.PublishedAt.String())

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/request.go

@@ -9,73 +9,47 @@ type Request struct {
 	sawyerReq *sawyer.Request
 }
 
-func (r *Request) Head(output interface{}) (resp *Response, err error) {
-	resp, err = r.do(sawyer.HeadMethod, nil, output)
-	return
+func (r *Request) Head(output interface{}) (*Response, error) {
+	return r.createResponse(r.sawyerReq.Head(), output)
 }
 
-func (r *Request) Get(output interface{}) (resp *Response, err error) {
-	resp, err = r.do(sawyer.GetMethod, nil, output)
-	return
+func (r *Request) Get(output interface{}) (*Response, error) {
+	return r.createResponse(r.sawyerReq.Get(), output)
 }
 
-func (r *Request) Post(input interface{}, output interface{}) (resp *Response, err error) {
-	resp, err = r.do(sawyer.PostMethod, input, output)
-	return
+func (r *Request) Post(input interface{}, output interface{}) (*Response, error) {
+	r.setBody(input)
+	return r.createResponse(r.sawyerReq.Post(), output)
 }
 
-func (r *Request) Put(input interface{}, output interface{}) (resp *Response, err error) {
-	resp, err = r.do(sawyer.PutMethod, input, output)
-	return
+func (r *Request) Put(input interface{}, output interface{}) (*Response, error) {
+	r.setBody(input)
+	return r.createResponse(r.sawyerReq.Put(), output)
 }
 
-func (r *Request) Delete(output interface{}) (resp *Response, err error) {
-	resp, err = r.do(sawyer.DeleteMethod, nil, output)
-	return
+func (r *Request) Delete(output interface{}) (*Response, error) {
+	return r.createResponse(r.sawyerReq.Delete(), output)
 }
 
-func (r *Request) Patch(input interface{}, output interface{}) (resp *Response, err error) {
-	resp, err = r.do(sawyer.PatchMethod, input, output)
-	return
+func (r *Request) Patch(input interface{}, output interface{}) (*Response, error) {
+	r.setBody(input)
+	return r.createResponse(r.sawyerReq.Patch(), output)
 }
 
-func (r *Request) do(method string, input interface{}, output interface{}) (resp *Response, err error) {
-	var sawyerResp *sawyer.Response
-	switch method {
-	case sawyer.HeadMethod:
-		sawyerResp = r.sawyerReq.Head()
-	case sawyer.GetMethod:
-		sawyerResp = r.sawyerReq.Get()
-	case sawyer.PostMethod:
-		mtype, _ := mediatype.Parse(defaultMediaType)
-		r.sawyerReq.SetBody(mtype, input)
-		sawyerResp = r.sawyerReq.Post()
-	case sawyer.PutMethod:
-		mtype, _ := mediatype.Parse(defaultMediaType)
-		r.sawyerReq.SetBody(mtype, input)
-		sawyerResp = r.sawyerReq.Put()
-	case sawyer.PatchMethod:
-		mtype, _ := mediatype.Parse(defaultMediaType)
-		r.sawyerReq.SetBody(mtype, input)
-		sawyerResp = r.sawyerReq.Patch()
-	case sawyer.DeleteMethod:
-		sawyerResp = r.sawyerReq.Delete()
-	case sawyer.OptionsMethod:
-		sawyerResp = r.sawyerReq.Options()
-	}
+func (r *Request) Options(output interface{}) (*Response, error) {
+	return r.createResponse(r.sawyerReq.Options(), output)
+}
 
-	if sawyerResp.IsError() {
-		err = sawyerResp.ResponseError
-		return
-	}
+func (r *Request) setBody(input interface{}) {
+	mtype, _ := mediatype.Parse(defaultMediaType)
+	r.sawyerReq.SetBody(mtype, input)
+}
 
-	if sawyerResp.IsApiError() {
-		err = NewResponseError(sawyerResp)
-		return
+func (r *Request) createResponse(sawyerResp *sawyer.Response, output interface{}) (resp *Response, err error) {
+	resp, err = NewResponse(sawyerResp)
+	if err == nil {
+		err = sawyerResp.Decode(output)
 	}
 
-	resp = &Response{Response: sawyerResp.Response, MediaType: sawyerResp.MediaType, MediaHeader: sawyerResp.MediaHeader}
-	err = sawyerResp.Decode(output)
-
 	return
 }

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/response.go

 package octokit
 
 import (
+	"github.com/lostisland/go-sawyer"
 	"github.com/lostisland/go-sawyer/mediaheader"
 	"github.com/lostisland/go-sawyer/mediatype"
 	"net/http"
@@ -11,3 +12,19 @@ type Response struct {
 	MediaHeader *mediaheader.MediaHeader
 	*http.Response
 }
+
+func NewResponse(sawyerResp *sawyer.Response) (resp *Response, err error) {
+	if sawyerResp.IsError() {
+		err = sawyerResp.ResponseError
+		return
+	}
+
+	if sawyerResp.IsApiError() {
+		err = NewResponseError(sawyerResp)
+		return
+	}
+
+	resp = &Response{Response: sawyerResp.Response, MediaType: sawyerResp.MediaType, MediaHeader: sawyerResp.MediaHeader}
+
+	return
+}

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/uploads.go

+package octokit
+
+import (
+	"net/url"
+	"os"
+)
+
+// Create an UploadsService with the base url.URL
+func (c *Client) Uploads(url *url.URL) *UploadsService {
+	return &UploadsService{client: c, URL: url}
+}
+
+type UploadsService struct {
+	client *Client
+	URL    *url.URL
+}
+
+func (u *UploadsService) UploadAsset(asset *os.File, contentType string) (result *Result) {
+	return u.client.upload(u.URL, asset, contentType)
+}

Godeps/_workspace/src/github.com/jingweno/go-octokit/octokit/uploads_test.go

+package octokit
+
+import (
+	"fmt"
+	"github.com/bmizerany/assert"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"testing"
+)
+
+func TestUploadsService_UploadAsset(t *testing.T) {
+	setup()
+	defer tearDown()
+
+	file, err := ioutil.TempFile("", "octokit-test-upload-")
+	assert.Equal(t, nil, err)
+	file.WriteString("this is a test")
+
+	fi, err := file.Stat()
+	assert.Equal(t, nil, err)
+	file.Close()
+
+	mux.HandleFunc("/repos/octokit/Hello-World/releases/123/assets", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "POST")
+		testHeader(t, r, "Content-Type", "text/plain")
+		assert.Equal(t, fi.Size(), r.ContentLength)
+		respondWithStatus(w, 201)
+	})
+
+	link := Hyperlink("/repos/octokit/Hello-World/releases/123/assets{?name}")
+	url, err := link.Expand(M{"name": fi.Name()})
+	assert.Equal(t, nil, err)
+
+	open, _ := os.Open(file.Name())
+	result := client.Uploads(url).UploadAsset(open, "text/plain")
+	fmt.Println(result)
+	assert.T(t, !result.HasError())
+
+	assert.Equal(t, 201, result.Response.StatusCode)
+}