Merge v1.2.1-master

Signed-off-by: Emile Vauge <emile@vauge.com>

vendor/github.com/google/go-github/LICENSE

@@ -29,8 +29,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------
 
 Some documentation is taken from the GitHub Developer site
-<http://developer.github.com/>, which is available under the following Creative
-Commons Attribution 3.0 License.  This applies only to the go-github source
+<https://developer.github.com/>, which is available under the following Creative
+Commons Attribution 3.0 License. This applies only to the go-github source
 code and would not apply to any compiled binaries.
 
 THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE

vendor/github.com/google/go-github/github/activity.go

@@ -5,10 +5,12 @@
 
 package github
 
+import "context"
+
 // ActivityService handles communication with the activity related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/
+// GitHub API docs: https://developer.github.com/v3/activity/
 type ActivityService service
 
 // FeedLink represents a link to a related resource.
@@ -51,14 +53,14 @@ type Feeds struct {
 //
 // Note: Private feeds are only returned when authenticating via Basic Auth
 // since current feed URIs use the older, non revocable auth tokens.
-func (s *ActivityService) ListFeeds() (*Feeds, *Response, error) {
+func (s *ActivityService) ListFeeds(ctx context.Context) (*Feeds, *Response, error) {
 	req, err := s.client.NewRequest("GET", "feeds", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	f := &Feeds{}
-	resp, err := s.client.Do(req, f)
+	resp, err := s.client.Do(ctx, req, f)
 	if err != nil {
 		return nil, resp, err
 	}

vendor/github.com/google/go-github/github/activity_events.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"time"
@@ -27,9 +28,9 @@ func (e Event) String() string {
 	return Stringify(e)
 }
 
-// Payload returns the parsed event payload. For recognized event types,
+// ParsePayload parses the event payload. For recognized event types,
 // a value of the corresponding struct type will be returned.
-func (e *Event) Payload() (payload interface{}) {
+func (e *Event) ParsePayload() (payload interface{}, err error) {
 	switch *e.Type {
 	case "CommitCommentEvent":
 		payload = &CommitCommentEvent{}
@@ -49,8 +50,6 @@ func (e *Event) Payload() (payload interface{}) {
 		payload = &IntegrationInstallationEvent{}
 	case "IntegrationInstallationRepositoriesEvent":
 		payload = &IntegrationInstallationRepositoriesEvent{}
-	case "IssueActivityEvent":
-		payload = &IssueActivityEvent{}
 	case "IssueCommentEvent":
 		payload = &IssueCommentEvent{}
 	case "IssuesEvent":
@@ -63,10 +62,18 @@ func (e *Event) Payload() (payload interface{}) {
 		payload = &MembershipEvent{}
 	case "MilestoneEvent":
 		payload = &MilestoneEvent{}
+	case "OrganizationEvent":
+		payload = &OrganizationEvent{}
 	case "PageBuildEvent":
 		payload = &PageBuildEvent{}
 	case "PingEvent":
 		payload = &PingEvent{}
+	case "ProjectEvent":
+		payload = &ProjectEvent{}
+	case "ProjectCardEvent":
+		payload = &ProjectCardEvent{}
+	case "ProjectColumnEvent":
+		payload = &ProjectColumnEvent{}
 	case "PublicEvent":
 		payload = &PublicEvent{}
 	case "PullRequestEvent":
@@ -88,16 +95,28 @@ func (e *Event) Payload() (payload interface{}) {
 	case "WatchEvent":
 		payload = &WatchEvent{}
 	}
-	if err := json.Unmarshal(*e.RawPayload, &payload); err != nil {
-		panic(err.Error())
+	err = json.Unmarshal(*e.RawPayload, &payload)
+	return payload, err
+}
+
+// Payload returns the parsed event payload. For recognized event types,
+// a value of the corresponding struct type will be returned.
+//
+// Deprecated: Use ParsePayload instead, which returns an error
+// rather than panics if JSON unmarshaling raw payload fails.
+func (e *Event) Payload() (payload interface{}) {
+	var err error
+	payload, err = e.ParsePayload()
+	if err != nil {
+		panic(err)
 	}
 	return payload
 }
 
 // ListEvents drinks from the firehose of all public events across GitHub.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-public-events
-func (s *ActivityService) ListEvents(opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-public-events
+func (s *ActivityService) ListEvents(ctx context.Context, opt *ListOptions) ([]*Event, *Response, error) {
 	u, err := addOptions("events", opt)
 	if err != nil {
 		return nil, nil, err
@@ -108,19 +127,19 @@ func (s *ActivityService) ListEvents(opt *ListOptions) ([]*Event, *Response, err
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListRepositoryEvents lists events for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-repository-events
-func (s *ActivityService) ListRepositoryEvents(owner, repo string, opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-repository-events
+func (s *ActivityService) ListRepositoryEvents(ctx context.Context, owner, repo string, opt *ListOptions) ([]*Event, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/events", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -132,19 +151,19 @@ func (s *ActivityService) ListRepositoryEvents(owner, repo string, opt *ListOpti
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListIssueEventsForRepository lists issue events for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-issue-events-for-a-repository
-func (s *ActivityService) ListIssueEventsForRepository(owner, repo string, opt *ListOptions) ([]*IssueEvent, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-issue-events-for-a-repository
+func (s *ActivityService) ListIssueEventsForRepository(ctx context.Context, owner, repo string, opt *ListOptions) ([]*IssueEvent, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/events", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -156,19 +175,19 @@ func (s *ActivityService) ListIssueEventsForRepository(owner, repo string, opt *
 		return nil, nil, err
 	}
 
-	events := new([]*IssueEvent)
-	resp, err := s.client.Do(req, events)
+	var events []*IssueEvent
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListEventsForRepoNetwork lists public events for a network of repositories.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-public-events-for-a-network-of-repositories
-func (s *ActivityService) ListEventsForRepoNetwork(owner, repo string, opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-public-events-for-a-network-of-repositories
+func (s *ActivityService) ListEventsForRepoNetwork(ctx context.Context, owner, repo string, opt *ListOptions) ([]*Event, *Response, error) {
 	u := fmt.Sprintf("networks/%v/%v/events", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -180,19 +199,19 @@ func (s *ActivityService) ListEventsForRepoNetwork(owner, repo string, opt *List
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListEventsForOrganization lists public events for an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-public-events-for-an-organization
-func (s *ActivityService) ListEventsForOrganization(org string, opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-public-events-for-an-organization
+func (s *ActivityService) ListEventsForOrganization(ctx context.Context, org string, opt *ListOptions) ([]*Event, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/events", org)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -204,20 +223,20 @@ func (s *ActivityService) ListEventsForOrganization(org string, opt *ListOptions
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListEventsPerformedByUser lists the events performed by a user. If publicOnly is
 // true, only public events will be returned.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-events-performed-by-a-user
-func (s *ActivityService) ListEventsPerformedByUser(user string, publicOnly bool, opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-events-performed-by-a-user
+func (s *ActivityService) ListEventsPerformedByUser(ctx context.Context, user string, publicOnly bool, opt *ListOptions) ([]*Event, *Response, error) {
 	var u string
 	if publicOnly {
 		u = fmt.Sprintf("users/%v/events/public", user)
@@ -234,20 +253,20 @@ func (s *ActivityService) ListEventsPerformedByUser(user string, publicOnly bool
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListEventsReceivedByUser lists the events received by a user. If publicOnly is
 // true, only public events will be returned.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-events-that-a-user-has-received
-func (s *ActivityService) ListEventsReceivedByUser(user string, publicOnly bool, opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-events-that-a-user-has-received
+func (s *ActivityService) ListEventsReceivedByUser(ctx context.Context, user string, publicOnly bool, opt *ListOptions) ([]*Event, *Response, error) {
 	var u string
 	if publicOnly {
 		u = fmt.Sprintf("users/%v/received_events/public", user)
@@ -264,20 +283,20 @@ func (s *ActivityService) ListEventsReceivedByUser(user string, publicOnly bool,
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }
 
 // ListUserEventsForOrganization provides the user’s organization dashboard. You
 // must be authenticated as the user to view this.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/#list-events-for-an-organization
-func (s *ActivityService) ListUserEventsForOrganization(org, user string, opt *ListOptions) ([]*Event, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/events/#list-events-for-an-organization
+func (s *ActivityService) ListUserEventsForOrganization(ctx context.Context, org, user string, opt *ListOptions) ([]*Event, *Response, error) {
 	u := fmt.Sprintf("users/%v/events/orgs/%v", user, org)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -289,11 +308,11 @@ func (s *ActivityService) ListUserEventsForOrganization(org, user string, opt *L
 		return nil, nil, err
 	}
 
-	events := new([]*Event)
-	resp, err := s.client.Do(req, events)
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *events, resp, err
+	return events, resp, nil
 }

vendor/github.com/google/go-github/github/activity_notifications.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -18,7 +19,7 @@ type Notification struct {
 
 	// Reason identifies the event that triggered the notification.
 	//
-	// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#notification-reasons
+	// GitHub API docs: https://developer.github.com/v3/activity/notifications/#notification-reasons
 	Reason *string `json:"reason,omitempty"`
 
 	Unread     *bool      `json:"unread,omitempty"`
@@ -48,8 +49,8 @@ type NotificationListOptions struct {
 
 // ListNotifications lists all notifications for the authenticated user.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications
-func (s *ActivityService) ListNotifications(opt *NotificationListOptions) ([]*Notification, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications
+func (s *ActivityService) ListNotifications(ctx context.Context, opt *NotificationListOptions) ([]*Notification, *Response, error) {
 	u := fmt.Sprintf("notifications")
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -62,19 +63,19 @@ func (s *ActivityService) ListNotifications(opt *NotificationListOptions) ([]*No
 	}
 
 	var notifications []*Notification
-	resp, err := s.client.Do(req, &notifications)
+	resp, err := s.client.Do(ctx, req, &notifications)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return notifications, resp, err
+	return notifications, resp, nil
 }
 
 // ListRepositoryNotifications lists all notifications in a given repository
 // for the authenticated user.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository
-func (s *ActivityService) ListRepositoryNotifications(owner, repo string, opt *NotificationListOptions) ([]*Notification, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository
+func (s *ActivityService) ListRepositoryNotifications(ctx context.Context, owner, repo string, opt *NotificationListOptions) ([]*Notification, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -87,12 +88,12 @@ func (s *ActivityService) ListRepositoryNotifications(owner, repo string, opt *N
 	}
 
 	var notifications []*Notification
-	resp, err := s.client.Do(req, &notifications)
+	resp, err := s.client.Do(ctx, req, &notifications)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return notifications, resp, err
+	return notifications, resp, nil
 }
 
 type markReadOptions struct {
@@ -101,8 +102,8 @@ type markReadOptions struct {
 
 // MarkNotificationsRead marks all notifications up to lastRead as read.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#mark-as-read
-func (s *ActivityService) MarkNotificationsRead(lastRead time.Time) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#mark-as-read
+func (s *ActivityService) MarkNotificationsRead(ctx context.Context, lastRead time.Time) (*Response, error) {
 	opts := &markReadOptions{
 		LastReadAt: lastRead,
 	}
@@ -111,14 +112,14 @@ func (s *ActivityService) MarkNotificationsRead(lastRead time.Time) (*Response,
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // MarkRepositoryNotificationsRead marks all notifications up to lastRead in
 // the specified repository as read.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository
-func (s *ActivityService) MarkRepositoryNotificationsRead(owner, repo string, lastRead time.Time) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository
+func (s *ActivityService) MarkRepositoryNotificationsRead(ctx context.Context, owner, repo string, lastRead time.Time) (*Response, error) {
 	opts := &markReadOptions{
 		LastReadAt: lastRead,
 	}
@@ -128,13 +129,13 @@ func (s *ActivityService) MarkRepositoryNotificationsRead(owner, repo string, la
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // GetThread gets the specified notification thread.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#view-a-single-thread
-func (s *ActivityService) GetThread(id string) (*Notification, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#view-a-single-thread
+func (s *ActivityService) GetThread(ctx context.Context, id string) (*Notification, *Response, error) {
 	u := fmt.Sprintf("notifications/threads/%v", id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -143,18 +144,18 @@ func (s *ActivityService) GetThread(id string) (*Notification, *Response, error)
 	}
 
 	notification := new(Notification)
-	resp, err := s.client.Do(req, notification)
+	resp, err := s.client.Do(ctx, req, notification)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return notification, resp, err
+	return notification, resp, nil
 }
 
 // MarkThreadRead marks the specified thread as read.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read
-func (s *ActivityService) MarkThreadRead(id string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read
+func (s *ActivityService) MarkThreadRead(ctx context.Context, id string) (*Response, error) {
 	u := fmt.Sprintf("notifications/threads/%v", id)
 
 	req, err := s.client.NewRequest("PATCH", u, nil)
@@ -162,14 +163,14 @@ func (s *ActivityService) MarkThreadRead(id string) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // GetThreadSubscription checks to see if the authenticated user is subscribed
 // to a thread.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription
-func (s *ActivityService) GetThreadSubscription(id string) (*Subscription, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription
+func (s *ActivityService) GetThreadSubscription(ctx context.Context, id string) (*Subscription, *Response, error) {
 	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -178,19 +179,19 @@ func (s *ActivityService) GetThreadSubscription(id string) (*Subscription, *Resp
 	}
 
 	sub := new(Subscription)
-	resp, err := s.client.Do(req, sub)
+	resp, err := s.client.Do(ctx, req, sub)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return sub, resp, err
+	return sub, resp, nil
 }
 
 // SetThreadSubscription sets the subscription for the specified thread for the
 // authenticated user.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription
-func (s *ActivityService) SetThreadSubscription(id string, subscription *Subscription) (*Subscription, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription
+func (s *ActivityService) SetThreadSubscription(ctx context.Context, id string, subscription *Subscription) (*Subscription, *Response, error) {
 	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
 
 	req, err := s.client.NewRequest("PUT", u, subscription)
@@ -199,24 +200,24 @@ func (s *ActivityService) SetThreadSubscription(id string, subscription *Subscri
 	}
 
 	sub := new(Subscription)
-	resp, err := s.client.Do(req, sub)
+	resp, err := s.client.Do(ctx, req, sub)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return sub, resp, err
+	return sub, resp, nil
 }
 
 // DeleteThreadSubscription deletes the subscription for the specified thread
 // for the authenticated user.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription
-func (s *ActivityService) DeleteThreadSubscription(id string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription
+func (s *ActivityService) DeleteThreadSubscription(ctx context.Context, id string) (*Response, error) {
 	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/activity_star.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // StarredRepository is returned by ListStarred.
 type StarredRepository struct {
@@ -21,8 +24,8 @@ type Stargazer struct {
 
 // ListStargazers lists people who have starred the specified repo.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/starring/#list-stargazers
-func (s *ActivityService) ListStargazers(owner, repo string, opt *ListOptions) ([]*Stargazer, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/starring/#list-stargazers
+func (s *ActivityService) ListStargazers(ctx context.Context, owner, repo string, opt *ListOptions) ([]*Stargazer, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/stargazers", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -37,34 +40,34 @@ func (s *ActivityService) ListStargazers(owner, repo string, opt *ListOptions) (
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeStarringPreview)
 
-	stargazers := new([]*Stargazer)
-	resp, err := s.client.Do(req, stargazers)
+	var stargazers []*Stargazer
+	resp, err := s.client.Do(ctx, req, &stargazers)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *stargazers, resp, err
+	return stargazers, resp, nil
 }
 
 // ActivityListStarredOptions specifies the optional parameters to the
 // ActivityService.ListStarred method.
 type ActivityListStarredOptions struct {
-	// How to sort the repository list.  Possible values are: created, updated,
-	// pushed, full_name.  Default is "full_name".
+	// How to sort the repository list. Possible values are: created, updated,
+	// pushed, full_name. Default is "full_name".
 	Sort string `url:"sort,omitempty"`
 
-	// Direction in which to sort repositories.  Possible values are: asc, desc.
+	// Direction in which to sort repositories. Possible values are: asc, desc.
 	// Default is "asc" when sort is "full_name", otherwise default is "desc".
 	Direction string `url:"direction,omitempty"`
 
 	ListOptions
 }
 
-// ListStarred lists all the repos starred by a user.  Passing the empty string
+// ListStarred lists all the repos starred by a user. Passing the empty string
 // will list the starred repositories for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/starring/#list-repositories-being-starred
-func (s *ActivityService) ListStarred(user string, opt *ActivityListStarredOptions) ([]*StarredRepository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/starring/#list-repositories-being-starred
+func (s *ActivityService) ListStarred(ctx context.Context, user string, opt *ActivityListStarredOptions) ([]*StarredRepository, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/starred", user)
@@ -84,25 +87,25 @@ func (s *ActivityService) ListStarred(user string, opt *ActivityListStarredOptio
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeStarringPreview)
 
-	repos := new([]*StarredRepository)
-	resp, err := s.client.Do(req, repos)
+	var repos []*StarredRepository
+	resp, err := s.client.Do(ctx, req, &repos)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *repos, resp, err
+	return repos, resp, nil
 }
 
 // IsStarred checks if a repository is starred by authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository
-func (s *ActivityService) IsStarred(owner, repo string) (bool, *Response, error) {
+func (s *ActivityService) IsStarred(ctx context.Context, owner, repo string) (bool, *Response, error) {
 	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	starred, err := parseBoolResponse(err)
 	return starred, resp, err
 }
@@ -110,23 +113,23 @@ func (s *ActivityService) IsStarred(owner, repo string) (bool, *Response, error)
 // Star a repository as the authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/activity/starring/#star-a-repository
-func (s *ActivityService) Star(owner, repo string) (*Response, error) {
+func (s *ActivityService) Star(ctx context.Context, owner, repo string) (*Response, error) {
 	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
 	req, err := s.client.NewRequest("PUT", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Unstar a repository as the authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/activity/starring/#unstar-a-repository
-func (s *ActivityService) Unstar(owner, repo string) (*Response, error) {
+func (s *ActivityService) Unstar(ctx context.Context, owner, repo string) (*Response, error) {
 	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/activity_watching.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Subscription identifies a repository or thread subscription.
 type Subscription struct {
@@ -24,8 +27,8 @@ type Subscription struct {
 
 // ListWatchers lists watchers of a particular repo.
 //
-// GitHub API Docs: http://developer.github.com/v3/activity/watching/#list-watchers
-func (s *ActivityService) ListWatchers(owner, repo string, opt *ListOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/watching/#list-watchers
+func (s *ActivityService) ListWatchers(ctx context.Context, owner, repo string, opt *ListOptions) ([]*User, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/subscribers", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -37,20 +40,20 @@ func (s *ActivityService) ListWatchers(owner, repo string, opt *ListOptions) ([]
 		return nil, nil, err
 	}
 
-	watchers := new([]*User)
-	resp, err := s.client.Do(req, watchers)
+	var watchers []*User
+	resp, err := s.client.Do(ctx, req, &watchers)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *watchers, resp, err
+	return watchers, resp, nil
 }
 
-// ListWatched lists the repositories the specified user is watching.  Passing
+// ListWatched lists the repositories the specified user is watching. Passing
 // the empty string will fetch watched repos for the authenticated user.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/watching/#list-repositories-being-watched
-func (s *ActivityService) ListWatched(user string, opt *ListOptions) ([]*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/watching/#list-repositories-being-watched
+func (s *ActivityService) ListWatched(ctx context.Context, user string, opt *ListOptions) ([]*Repository, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/subscriptions", user)
@@ -67,21 +70,21 @@ func (s *ActivityService) ListWatched(user string, opt *ListOptions) ([]*Reposit
 		return nil, nil, err
 	}
 
-	watched := new([]*Repository)
-	resp, err := s.client.Do(req, watched)
+	var watched []*Repository
+	resp, err := s.client.Do(ctx, req, &watched)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *watched, resp, err
+	return watched, resp, nil
 }
 
 // GetRepositorySubscription returns the subscription for the specified
-// repository for the authenticated user.  If the authenticated user is not
+// repository for the authenticated user. If the authenticated user is not
 // watching the repository, a nil Subscription is returned.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/watching/#get-a-repository-subscription
-func (s *ActivityService) GetRepositorySubscription(owner, repo string) (*Subscription, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/watching/#get-a-repository-subscription
+func (s *ActivityService) GetRepositorySubscription(ctx context.Context, owner, repo string) (*Subscription, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -90,14 +93,14 @@ func (s *ActivityService) GetRepositorySubscription(owner, repo string) (*Subscr
 	}
 
 	sub := new(Subscription)
-	resp, err := s.client.Do(req, sub)
+	resp, err := s.client.Do(ctx, req, sub)
 	if err != nil {
 		// if it's just a 404, don't return that as an error
 		_, err = parseBoolResponse(err)
 		return nil, resp, err
 	}
 
-	return sub, resp, err
+	return sub, resp, nil
 }
 
 // SetRepositorySubscription sets the subscription for the specified repository
@@ -107,8 +110,8 @@ func (s *ActivityService) GetRepositorySubscription(owner, repo string) (*Subscr
 // To ignore notifications made within a repository, set subscription.Ignored to true.
 // To stop watching a repository, use DeleteRepositorySubscription.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/watching/#set-a-repository-subscription
-func (s *ActivityService) SetRepositorySubscription(owner, repo string, subscription *Subscription) (*Subscription, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/watching/#set-a-repository-subscription
+func (s *ActivityService) SetRepositorySubscription(ctx context.Context, owner, repo string, subscription *Subscription) (*Subscription, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
 
 	req, err := s.client.NewRequest("PUT", u, subscription)
@@ -117,12 +120,12 @@ func (s *ActivityService) SetRepositorySubscription(owner, repo string, subscrip
 	}
 
 	sub := new(Subscription)
-	resp, err := s.client.Do(req, sub)
+	resp, err := s.client.Do(ctx, req, sub)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return sub, resp, err
+	return sub, resp, nil
 }
 
 // DeleteRepositorySubscription deletes the subscription for the specified
@@ -131,13 +134,13 @@ func (s *ActivityService) SetRepositorySubscription(owner, repo string, subscrip
 // This is used to stop watching a repository. To control whether or not to
 // receive notifications from a repository, use SetRepositorySubscription.
 //
-// GitHub API Docs: https://developer.github.com/v3/activity/watching/#delete-a-repository-subscription
-func (s *ActivityService) DeleteRepositorySubscription(owner, repo string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/activity/watching/#delete-a-repository-subscription
+func (s *ActivityService) DeleteRepositorySubscription(ctx context.Context, owner, repo string) (*Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/admin.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // AdminService handles communication with the admin related methods of the
 // GitHub API. These API routes are normally only accessible for GitHub
@@ -62,7 +65,7 @@ func (m UserLDAPMapping) String() string {
 // UpdateUserLDAPMapping updates the mapping between a GitHub user and an LDAP user.
 //
 // GitHub API docs: https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-user
-func (s *AdminService) UpdateUserLDAPMapping(user string, mapping *UserLDAPMapping) (*UserLDAPMapping, *Response, error) {
+func (s *AdminService) UpdateUserLDAPMapping(ctx context.Context, user string, mapping *UserLDAPMapping) (*UserLDAPMapping, *Response, error) {
 	u := fmt.Sprintf("admin/ldap/users/%v/mapping", user)
 	req, err := s.client.NewRequest("PATCH", u, mapping)
 	if err != nil {
@@ -70,18 +73,18 @@ func (s *AdminService) UpdateUserLDAPMapping(user string, mapping *UserLDAPMappi
 	}
 
 	m := new(UserLDAPMapping)
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return m, resp, err
+	return m, resp, nil
 }
 
 // UpdateTeamLDAPMapping updates the mapping between a GitHub team and an LDAP group.
 //
 // GitHub API docs: https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-team
-func (s *AdminService) UpdateTeamLDAPMapping(team int, mapping *TeamLDAPMapping) (*TeamLDAPMapping, *Response, error) {
+func (s *AdminService) UpdateTeamLDAPMapping(ctx context.Context, team int, mapping *TeamLDAPMapping) (*TeamLDAPMapping, *Response, error) {
 	u := fmt.Sprintf("admin/ldap/teams/%v/mapping", team)
 	req, err := s.client.NewRequest("PATCH", u, mapping)
 	if err != nil {
@@ -89,10 +92,10 @@ func (s *AdminService) UpdateTeamLDAPMapping(team int, mapping *TeamLDAPMapping)
 	}
 
 	m := new(TeamLDAPMapping)
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return m, resp, err
+	return m, resp, nil
 }

vendor/github.com/google/go-github/github/authorizations.go

@@ -5,11 +5,14 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Scope models a GitHub authorization scope.
 //
-// GitHub API docs:https://developer.github.com/v3/oauth/#scopes
+// GitHub API docs: https://developer.github.com/v3/oauth/#scopes
 type Scope string
 
 // This is the set of scopes for GitHub API V3
@@ -114,7 +117,7 @@ func (a AuthorizationRequest) String() string {
 // AuthorizationUpdateRequest represents a request to update an authorization.
 //
 // Note that for any one update, you must only provide one of the "scopes"
-// fields.  That is, you may provide only one of "Scopes", or "AddScopes", or
+// fields. That is, you may provide only one of "Scopes", or "AddScopes", or
 // "RemoveScopes".
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization
@@ -134,7 +137,7 @@ func (a AuthorizationUpdateRequest) String() string {
 // List the authorizations for the authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations
-func (s *AuthorizationsService) List(opt *ListOptions) ([]*Authorization, *Response, error) {
+func (s *AuthorizationsService) List(ctx context.Context, opt *ListOptions) ([]*Authorization, *Response, error) {
 	u := "authorizations"
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -146,18 +149,18 @@ func (s *AuthorizationsService) List(opt *ListOptions) ([]*Authorization, *Respo
 		return nil, nil, err
 	}
 
-	auths := new([]*Authorization)
-	resp, err := s.client.Do(req, auths)
+	var auths []*Authorization
+	resp, err := s.client.Do(ctx, req, &auths)
 	if err != nil {
 		return nil, resp, err
 	}
-	return *auths, resp, err
+	return auths, resp, nil
 }
 
 // Get a single authorization.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization
-func (s *AuthorizationsService) Get(id int) (*Authorization, *Response, error) {
+func (s *AuthorizationsService) Get(ctx context.Context, id int) (*Authorization, *Response, error) {
 	u := fmt.Sprintf("authorizations/%d", id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -166,17 +169,17 @@ func (s *AuthorizationsService) Get(id int) (*Authorization, *Response, error) {
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
-	return a, resp, err
+	return a, resp, nil
 }
 
 // Create a new authorization for the specified OAuth application.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization
-func (s *AuthorizationsService) Create(auth *AuthorizationRequest) (*Authorization, *Response, error) {
+func (s *AuthorizationsService) Create(ctx context.Context, auth *AuthorizationRequest) (*Authorization, *Response, error) {
 	u := "authorizations"
 
 	req, err := s.client.NewRequest("POST", u, auth)
@@ -185,11 +188,11 @@ func (s *AuthorizationsService) Create(auth *AuthorizationRequest) (*Authorizati
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
-	return a, resp, err
+	return a, resp, nil
 }
 
 // GetOrCreateForApp creates a new authorization for the specified OAuth
@@ -204,9 +207,9 @@ func (s *AuthorizationsService) Create(auth *AuthorizationRequest) (*Authorizati
 // clientID is the OAuth Client ID with which to create the token.
 //
 // GitHub API docs:
-// - https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app
-// - https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app-and-fingerprint
-func (s *AuthorizationsService) GetOrCreateForApp(clientID string, auth *AuthorizationRequest) (*Authorization, *Response, error) {
+// https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app
+// https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app-and-fingerprint
+func (s *AuthorizationsService) GetOrCreateForApp(ctx context.Context, clientID string, auth *AuthorizationRequest) (*Authorization, *Response, error) {
 	var u string
 	if auth.Fingerprint == nil || *auth.Fingerprint == "" {
 		u = fmt.Sprintf("authorizations/clients/%v", clientID)
@@ -220,18 +223,18 @@ func (s *AuthorizationsService) GetOrCreateForApp(clientID string, auth *Authori
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return a, resp, err
+	return a, resp, nil
 }
 
 // Edit a single authorization.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization
-func (s *AuthorizationsService) Edit(id int, auth *AuthorizationUpdateRequest) (*Authorization, *Response, error) {
+func (s *AuthorizationsService) Edit(ctx context.Context, id int, auth *AuthorizationUpdateRequest) (*Authorization, *Response, error) {
 	u := fmt.Sprintf("authorizations/%d", id)
 
 	req, err := s.client.NewRequest("PATCH", u, auth)
@@ -240,18 +243,18 @@ func (s *AuthorizationsService) Edit(id int, auth *AuthorizationUpdateRequest) (
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return a, resp, err
+	return a, resp, nil
 }
 
 // Delete a single authorization.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization
-func (s *AuthorizationsService) Delete(id int) (*Response, error) {
+func (s *AuthorizationsService) Delete(ctx context.Context, id int) (*Response, error) {
 	u := fmt.Sprintf("authorizations/%d", id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -259,7 +262,7 @@ func (s *AuthorizationsService) Delete(id int) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Check if an OAuth token is valid for a specific app.
@@ -271,7 +274,7 @@ func (s *AuthorizationsService) Delete(id int) (*Response, error) {
 // The returned Authorization.User field will be populated.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#check-an-authorization
-func (s *AuthorizationsService) Check(clientID string, token string) (*Authorization, *Response, error) {
+func (s *AuthorizationsService) Check(ctx context.Context, clientID string, token string) (*Authorization, *Response, error) {
 	u := fmt.Sprintf("applications/%v/tokens/%v", clientID, token)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -280,12 +283,12 @@ func (s *AuthorizationsService) Check(clientID string, token string) (*Authoriza
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return a, resp, err
+	return a, resp, nil
 }
 
 // Reset is used to reset a valid OAuth token without end user involvement.
@@ -299,7 +302,7 @@ func (s *AuthorizationsService) Check(clientID string, token string) (*Authoriza
 // The returned Authorization.User field will be populated.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#reset-an-authorization
-func (s *AuthorizationsService) Reset(clientID string, token string) (*Authorization, *Response, error) {
+func (s *AuthorizationsService) Reset(ctx context.Context, clientID string, token string) (*Authorization, *Response, error) {
 	u := fmt.Sprintf("applications/%v/tokens/%v", clientID, token)
 
 	req, err := s.client.NewRequest("POST", u, nil)
@@ -308,12 +311,12 @@ func (s *AuthorizationsService) Reset(clientID string, token string) (*Authoriza
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return a, resp, err
+	return a, resp, nil
 }
 
 // Revoke an authorization for an application.
@@ -323,7 +326,7 @@ func (s *AuthorizationsService) Reset(clientID string, token string) (*Authoriza
 // clientSecret. Invalid tokens will return a 404 Not Found.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#revoke-an-authorization-for-an-application
-func (s *AuthorizationsService) Revoke(clientID string, token string) (*Response, error) {
+func (s *AuthorizationsService) Revoke(ctx context.Context, clientID string, token string) (*Response, error) {
 	u := fmt.Sprintf("applications/%v/tokens/%v", clientID, token)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -331,7 +334,7 @@ func (s *AuthorizationsService) Revoke(clientID string, token string) (*Response
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ListGrants lists the set of OAuth applications that have been granted
@@ -340,25 +343,25 @@ func (s *AuthorizationsService) Revoke(clientID string, token string) (*Response
 // tokens an application has generated for the user.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#list-your-grants
-func (s *AuthorizationsService) ListGrants() ([]*Grant, *Response, error) {
+func (s *AuthorizationsService) ListGrants(ctx context.Context) ([]*Grant, *Response, error) {
 	req, err := s.client.NewRequest("GET", "applications/grants", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	grants := []*Grant{}
-	resp, err := s.client.Do(req, &grants)
+	resp, err := s.client.Do(ctx, req, &grants)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return grants, resp, err
+	return grants, resp, nil
 }
 
 // GetGrant gets a single OAuth application grant.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#get-a-single-grant
-func (s *AuthorizationsService) GetGrant(id int) (*Grant, *Response, error) {
+func (s *AuthorizationsService) GetGrant(ctx context.Context, id int) (*Grant, *Response, error) {
 	u := fmt.Sprintf("applications/grants/%d", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -366,12 +369,12 @@ func (s *AuthorizationsService) GetGrant(id int) (*Grant, *Response, error) {
 	}
 
 	grant := new(Grant)
-	resp, err := s.client.Do(req, grant)
+	resp, err := s.client.Do(ctx, req, grant)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return grant, resp, err
+	return grant, resp, nil
 }
 
 // DeleteGrant deletes an OAuth application grant. Deleting an application's
@@ -379,14 +382,14 @@ func (s *AuthorizationsService) GetGrant(id int) (*Grant, *Response, error) {
 // the user.
 //
 // GitHub API docs: https://developer.github.com/v3/oauth_authorizations/#delete-a-grant
-func (s *AuthorizationsService) DeleteGrant(id int) (*Response, error) {
+func (s *AuthorizationsService) DeleteGrant(ctx context.Context, id int) (*Response, error) {
 	u := fmt.Sprintf("applications/grants/%d", id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // CreateImpersonation creates an impersonation OAuth token.
@@ -396,7 +399,7 @@ func (s *AuthorizationsService) DeleteGrant(id int) (*Response, error) {
 // new token automatically revokes an existing one.
 //
 // GitHub API docs: https://developer.github.com/enterprise/2.5/v3/users/administration/#create-an-impersonation-oauth-token
-func (s *AuthorizationsService) CreateImpersonation(username string, authReq *AuthorizationRequest) (*Authorization, *Response, error) {
+func (s *AuthorizationsService) CreateImpersonation(ctx context.Context, username string, authReq *AuthorizationRequest) (*Authorization, *Response, error) {
 	u := fmt.Sprintf("admin/users/%v/authorizations", username)
 	req, err := s.client.NewRequest("POST", u, authReq)
 	if err != nil {
@@ -404,11 +407,11 @@ func (s *AuthorizationsService) CreateImpersonation(username string, authReq *Au
 	}
 
 	a := new(Authorization)
-	resp, err := s.client.Do(req, a)
+	resp, err := s.client.Do(ctx, req, a)
 	if err != nil {
 		return nil, resp, err
 	}
-	return a, resp, err
+	return a, resp, nil
 }
 
 // DeleteImpersonation deletes an impersonation OAuth token.
@@ -416,12 +419,12 @@ func (s *AuthorizationsService) CreateImpersonation(username string, authReq *Au
 // NOTE: there can be only one at a time.
 //
 // GitHub API docs: https://developer.github.com/enterprise/2.5/v3/users/administration/#delete-an-impersonation-oauth-token
-func (s *AuthorizationsService) DeleteImpersonation(username string) (*Response, error) {
+func (s *AuthorizationsService) DeleteImpersonation(ctx context.Context, username string) (*Response, error) {
 	u := fmt.Sprintf("admin/users/%v/authorizations", username)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/doc.go

@@ -16,7 +16,7 @@ access different parts of the GitHub API. For example:
 	client := github.NewClient(nil)
 
 	// list all organizations for user "willnorris"
-	orgs, _, err := client.Organizations.List("willnorris", nil)
+	orgs, _, err := client.Organizations.List(ctx, "willnorris", nil)
 
 Some API methods have optional parameters that can be passed. For example:
 
@@ -24,11 +24,11 @@ Some API methods have optional parameters that can be passed. For example:
 
 	// list public repositories for org "github"
 	opt := &github.RepositoryListByOrgOptions{Type: "public"}
-	repos, _, err := client.Repositories.ListByOrg("github", opt)
+	repos, _, err := client.Repositories.ListByOrg(ctx, "github", opt)
 
 The services of a client divide the API into logical chunks and correspond to
 the structure of the GitHub API documentation at
-http://developer.github.com/v3/.
+https://developer.github.com/v3/.
 
 Authentication
 
@@ -42,15 +42,16 @@ use it with the oauth2 library using:
 	import "golang.org/x/oauth2"
 
 	func main() {
+		ctx := context.Background()
 		ts := oauth2.StaticTokenSource(
 			&oauth2.Token{AccessToken: "... your access token ..."},
 		)
-		tc := oauth2.NewClient(oauth2.NoContext, ts)
+		tc := oauth2.NewClient(ctx, ts)
 
 		client := github.NewClient(tc)
 
 		// list all repositories for the authenticated user
-		repos, _, err := client.Repositories.List("", nil)
+		repos, _, err := client.Repositories.List(ctx, "", nil)
 	}
 
 Note that when using an authenticated Client, all calls made by the client will
@@ -78,13 +79,13 @@ up-to-date rate limit data for the client.
 
 To detect an API rate limit error, you can check if its type is *github.RateLimitError:
 
-	repos, _, err := client.Repositories.List("", nil)
+	repos, _, err := client.Repositories.List(ctx, "", nil)
 	if _, ok := err.(*github.RateLimitError); ok {
 		log.Println("hit rate limit")
 	}
 
 Learn more about GitHub rate limiting at
-http://developer.github.com/v3/#rate-limiting.
+https://developer.github.com/v3/#rate-limiting.
 
 Accepted Status
 
@@ -96,7 +97,7 @@ this behavior.
 To detect this condition of error, you can check if its type is
 *github.AcceptedError:
 
-	stats, _, err := client.Repositories.ListContributorsStats(org, repo)
+	stats, _, err := client.Repositories.ListContributorsStats(ctx, org, repo)
 	if _, ok := err.(*github.AcceptedError); ok {
 		log.Println("scheduled on GitHub side")
 	}
@@ -124,7 +125,7 @@ bool, and int values. For example:
 		Name:    github.String("foo"),
 		Private: github.Bool(true),
 	}
-	client.Repositories.Create("", repo)
+	client.Repositories.Create(ctx, "", repo)
 
 Users who have worked with protocol buffers should find this pattern familiar.
 
@@ -145,7 +146,7 @@ github.Response struct.
 	// get all pages of results
 	var allRepos []*github.Repository
 	for {
-		repos, resp, err := client.Repositories.ListByOrg("github", opt)
+		repos, resp, err := client.Repositories.ListByOrg(ctx, "github", opt)
 		if err != nil {
 			return err
 		}
@@ -156,5 +157,16 @@ github.Response struct.
 		opt.ListOptions.Page = resp.NextPage
 	}
 
+Google App Engine
+
+Go on App Engine Classic (which as of this writing uses Go 1.6) can not use
+the "context" import and still relies on "golang.org/x/net/context".
+As a result, if you wish to continue to use "go-github" on App Engine Classic,
+you will need to rewrite all the "context" imports using the following command:
+
+    gofmt -w -r '"context" -> "golang.org/x/net/context"' *.go
+
+See "with_appengine.go" for more details.
+
 */
 package github

vendor/github.com/google/go-github/github/event_types.go

@@ -10,14 +10,15 @@ package github
 // CommitCommentEvent is triggered when a commit comment is created.
 // The Webhook event name is "commit_comment".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#commitcommentevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#commitcommentevent
 type CommitCommentEvent struct {
 	Comment *RepositoryComment `json:"comment,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Action *string     `json:"action,omitempty"`
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Action       *string       `json:"action,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // CreateEvent represents a created repository, branch, or tag.
@@ -27,7 +28,7 @@ type CommitCommentEvent struct {
 // Additionally, webhooks will not receive this event for tags if more
 // than three tags are pushed at once.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#createevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#createevent
 type CreateEvent struct {
 	Ref *string `json:"ref,omitempty"`
 	// RefType is the object that was created. Possible values are: "repository", "branch", "tag".
@@ -36,9 +37,10 @@ type CreateEvent struct {
 	Description  *string `json:"description,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	PusherType *string     `json:"pusher_type,omitempty"`
-	Repo       *Repository `json:"repository,omitempty"`
-	Sender     *User       `json:"sender,omitempty"`
+	PusherType   *string       `json:"pusher_type,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // DeleteEvent represents a deleted branch or tag.
@@ -47,16 +49,17 @@ type CreateEvent struct {
 // Note: webhooks will not receive this event for tags if more than three tags
 // are deleted at once.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#deleteevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deleteevent
 type DeleteEvent struct {
 	Ref *string `json:"ref,omitempty"`
 	// RefType is the object that was deleted. Possible values are: "branch", "tag".
 	RefType *string `json:"ref_type,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	PusherType *string     `json:"pusher_type,omitempty"`
-	Repo       *Repository `json:"repository,omitempty"`
-	Sender     *User       `json:"sender,omitempty"`
+	PusherType   *string       `json:"pusher_type,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // DeploymentEvent represents a deployment.
@@ -64,13 +67,14 @@ type DeleteEvent struct {
 //
 // Events of this type are not visible in timelines, they are only used to trigger hooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#deploymentevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deploymentevent
 type DeploymentEvent struct {
 	Deployment *Deployment `json:"deployment,omitempty"`
 	Repo       *Repository `json:"repository,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Sender *User `json:"sender,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // DeploymentStatusEvent represents a deployment status.
@@ -78,27 +82,29 @@ type DeploymentEvent struct {
 //
 // Events of this type are not visible in timelines, they are only used to trigger hooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#deploymentstatusevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#deploymentstatusevent
 type DeploymentStatusEvent struct {
 	Deployment       *Deployment       `json:"deployment,omitempty"`
 	DeploymentStatus *DeploymentStatus `json:"deployment_status,omitempty"`
 	Repo             *Repository       `json:"repository,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Sender *User `json:"sender,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // ForkEvent is triggered when a user forks a repository.
 // The Webhook event name is "fork".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#forkevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#forkevent
 type ForkEvent struct {
 	// Forkee is the created repository.
 	Forkee *Repository `json:"forkee,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // Page represents a single Wiki page.
@@ -114,25 +120,14 @@ type Page struct {
 // GollumEvent is triggered when a Wiki page is created or updated.
 // The Webhook event name is "gollum".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#gollumevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#gollumevent
 type GollumEvent struct {
 	Pages []*Page `json:"pages,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
-}
-
-// IssueActivityEvent represents the payload delivered by Issue webhook.
-//
-// Deprecated: Use IssuesEvent instead.
-type IssueActivityEvent struct {
-	Action *string `json:"action,omitempty"`
-	Issue  *Issue  `json:"issue,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // EditChange represents the changes when an issue, pull request, or comment has
@@ -146,37 +141,61 @@ type EditChange struct {
 	} `json:"body,omitempty"`
 }
 
+// ProjectChange represents the changes when a project has been edited.
+type ProjectChange struct {
+	Name *struct {
+		From *string `json:"from,omitempty"`
+	} `json:"name,omitempty"`
+	Body *struct {
+		From *string `json:"from,omitempty"`
+	} `json:"body,omitempty"`
+}
+
+// ProjectCardChange represents the changes when a project card has been edited.
+type ProjectCardChange struct {
+	Note *struct {
+		From *string `json:"from,omitempty"`
+	} `json:"note,omitempty"`
+}
+
+// ProjectColumnChange represents the changes when a project column has been edited.
+type ProjectColumnChange struct {
+	Name *struct {
+		From *string `json:"from,omitempty"`
+	} `json:"name,omitempty"`
+}
+
 // IntegrationInstallationEvent is triggered when an integration is created or deleted.
 // The Webhook event name is "integration_installation".
 //
-// GitHub docs: https://developer.github.com/early-access/integrations/webhooks/#integrationinstallationevent
+// GitHub API docs: https://developer.github.com/early-access/integrations/webhooks/#integrationinstallationevent
 type IntegrationInstallationEvent struct {
 	// The action that was performed. Possible values for an "integration_installation"
 	// event are: "created", "deleted".
 	Action       *string       `json:"action,omitempty"`
-	Installation *Installation `json:"installation,omitempty"`
 	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // IntegrationInstallationRepositoriesEvent is triggered when an integration repository
 // is added or removed. The Webhook event name is "integration_installation_repositories".
 //
-// GitHub docs: https://developer.github.com/early-access/integrations/webhooks/#integrationinstallationrepositoriesevent
+// GitHub API docs: https://developer.github.com/early-access/integrations/webhooks/#integrationinstallationrepositoriesevent
 type IntegrationInstallationRepositoriesEvent struct {
 	// The action that was performed. Possible values for an "integration_installation_repositories"
 	// event are: "added", "removed".
 	Action              *string       `json:"action,omitempty"`
-	Installation        *Installation `json:"installation,omitempty"`
 	RepositoriesAdded   []*Repository `json:"repositories_added,omitempty"`
 	RepositoriesRemoved []*Repository `json:"repositories_removed,omitempty"`
 	Sender              *User         `json:"sender,omitempty"`
+	Installation        *Installation `json:"installation,omitempty"`
 }
 
 // IssueCommentEvent is triggered when an issue comment is created on an issue
 // or pull request.
 // The Webhook event name is "issue_comment".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#issuecommentevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#issuecommentevent
 type IssueCommentEvent struct {
 	// Action is the action that was performed on the comment.
 	// Possible values are: "created", "edited", "deleted".
@@ -185,16 +204,17 @@ type IssueCommentEvent struct {
 	Comment *IssueComment `json:"comment,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Changes *EditChange `json:"changes,omitempty"`
-	Repo    *Repository `json:"repository,omitempty"`
-	Sender  *User       `json:"sender,omitempty"`
+	Changes      *EditChange   `json:"changes,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // IssuesEvent is triggered when an issue is assigned, unassigned, labeled,
 // unlabeled, opened, closed, or reopened.
 // The Webhook event name is "issues".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#issuesevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#issuesevent
 type IssuesEvent struct {
 	// Action is the action that was performed. Possible values are: "assigned",
 	// "unassigned", "labeled", "unlabeled", "opened", "closed", "reopened", "edited".
@@ -204,15 +224,16 @@ type IssuesEvent struct {
 	Label    *Label  `json:"label,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Changes *EditChange `json:"changes,omitempty"`
-	Repo    *Repository `json:"repository,omitempty"`
-	Sender  *User       `json:"sender,omitempty"`
+	Changes      *EditChange   `json:"changes,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // LabelEvent is triggered when a repository's label is created, edited, or deleted.
 // The Webhook event name is "label"
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#labelevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#labelevent
 type LabelEvent struct {
 	// Action is the action that was performed. Possible values are:
 	// "created", "edited", "deleted"
@@ -220,23 +241,25 @@ type LabelEvent struct {
 	Label  *Label  `json:"label,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Changes *EditChange   `json:"changes,omitempty"`
-	Repo    *Repository   `json:"repository,omitempty"`
-	Org     *Organization `json:"organization,omitempty"`
+	Changes      *EditChange   `json:"changes,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // MemberEvent is triggered when a user is added as a collaborator to a repository.
 // The Webhook event name is "member".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#memberevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#memberevent
 type MemberEvent struct {
 	// Action is the action that was performed. Possible value is: "added".
 	Action *string `json:"action,omitempty"`
 	Member *User   `json:"member,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // MembershipEvent is triggered when a user is added or removed from a team.
@@ -245,7 +268,7 @@ type MemberEvent struct {
 // Events of this type are not visible in timelines, they are only used to
 // trigger organization webhooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#membershipevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#membershipevent
 type MembershipEvent struct {
 	// Action is the action that was performed. Possible values are: "added", "removed".
 	Action *string `json:"action,omitempty"`
@@ -255,14 +278,15 @@ type MembershipEvent struct {
 	Team   *Team   `json:"team,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Org    *Organization `json:"organization,omitempty"`
-	Sender *User         `json:"sender,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // MilestoneEvent is triggered when a milestone is created, closed, opened, edited, or deleted.
 // The Webhook event name is "milestone".
 //
-// Github docs: https://developer.github.com/v3/activity/events/types/#milestoneevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#milestoneevent
 type MilestoneEvent struct {
 	// Action is the action that was performed. Possible values are:
 	// "created", "closed", "opened", "edited", "deleted"
@@ -270,10 +294,33 @@ type MilestoneEvent struct {
 	Milestone *Milestone `json:"milestone,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Changes *EditChange   `json:"changes,omitempty"`
-	Repo    *Repository   `json:"repository,omitempty"`
-	Sender  *User         `json:"sender,omitempty"`
-	Org     *Organization `json:"organization,omitempty"`
+	Changes      *EditChange   `json:"changes,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
+}
+
+// OrganizationEvent is triggered when a user is added, removed, or invited to an organization.
+// Events of this type are not visible in timelines. These events are only used to trigger organization hooks.
+// Webhook event name is "organization".
+//
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#organizationevent
+type OrganizationEvent struct {
+	// Action is the action that was performed.
+	// Can be one of "member_added", "member_removed", or "member_invited".
+	Action *string `json:"action,omitempty"`
+
+	// Invitaion is the invitation for the user or email if the action is "member_invited".
+	Invitation *Invitation `json:"invitation,omitempty"`
+
+	// Membership is the membership between the user and the organization.
+	// Not present when the action is "member_invited".
+	Membership *Membership `json:"membership,omitempty"`
+
+	Organization *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // PageBuildEvent represents an attempted build of a GitHub Pages site, whether
@@ -285,44 +332,97 @@ type MilestoneEvent struct {
 //
 // Events of this type are not visible in timelines, they are only used to trigger hooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#pagebuildevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pagebuildevent
 type PageBuildEvent struct {
 	Build *PagesBuild `json:"build,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	ID     *int        `json:"id,omitempty"`
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	ID           *int          `json:"id,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // PingEvent is triggered when a Webhook is added to GitHub.
 //
-// GitHub docs: https://developer.github.com/webhooks/#ping-event
+// GitHub API docs: https://developer.github.com/webhooks/#ping-event
 type PingEvent struct {
 	// Random string of GitHub zen.
 	Zen *string `json:"zen,omitempty"`
 	// The ID of the webhook that triggered the ping.
 	HookID *int `json:"hook_id,omitempty"`
 	// The webhook configuration.
-	Hook *Hook `json:"hook,omitempty"`
+	Hook         *Hook         `json:"hook,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
+}
+
+// ProjectEvent is triggered when project is created, modified or deleted.
+// The webhook event name is "project".
+//
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#projectevent
+type ProjectEvent struct {
+	Action  *string        `json:"action,omitempty"`
+	Changes *ProjectChange `json:"changes,omitempty"`
+	Project *Project       `json:"project,omitempty"`
+
+	// The following fields are only populated by Webhook events.
+	Repo         *Repository   `json:"repository,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
+}
+
+// ProjectCardEvent is triggered when a project card is created, updated, moved, converted to an issue, or deleted.
+// The webhook event name is "project_card".
+//
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#projectcardevent
+type ProjectCardEvent struct {
+	Action      *string            `json:"action,omitempty"`
+	Changes     *ProjectCardChange `json:"changes,omitempty"`
+	AfterID     *int               `json:"after_id,omitempty"`
+	ProjectCard *ProjectCard       `json:"project_card,omitempty"`
+
+	// The following fields are only populated by Webhook events.
+	Repo         *Repository   `json:"repository,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
+}
+
+// ProjectColumnEvent is triggered when a project column is created, updated, moved, or deleted.
+// The webhook event name is "project_column".
+//
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#projectcolumnevent
+type ProjectColumnEvent struct {
+	Action        *string              `json:"action,omitempty"`
+	Changes       *ProjectColumnChange `json:"changes,omitempty"`
+	AfterID       *int                 `json:"after_id,omitempty"`
+	ProjectColumn *ProjectColumn       `json:"project_column,omitempty"`
+
+	// The following fields are only populated by Webhook events.
+	Repo         *Repository   `json:"repository,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // PublicEvent is triggered when a private repository is open sourced.
 // According to GitHub: "Without a doubt: the best GitHub event."
 // The Webhook event name is "public".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#publicevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#publicevent
 type PublicEvent struct {
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // PullRequestEvent is triggered when a pull request is assigned, unassigned,
 // labeled, unlabeled, opened, closed, reopened, or synchronized.
 // The Webhook event name is "pull_request".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#pullrequestevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pullrequestevent
 type PullRequestEvent struct {
 	// Action is the action that was performed. Possible values are: "assigned",
 	// "unassigned", "labeled", "unlabeled", "opened", "closed", or "reopened",
@@ -334,16 +434,17 @@ type PullRequestEvent struct {
 	PullRequest *PullRequest `json:"pull_request,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Changes *EditChange `json:"changes,omitempty"`
-	Repo    *Repository `json:"repository,omitempty"`
-	Sender  *User       `json:"sender,omitempty"`
+	Changes      *EditChange   `json:"changes,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // PullRequestReviewEvent is triggered when a review is submitted on a pull
 // request.
 // The Webhook event name is "pull_request_review".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#pullrequestreviewevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pullrequestreviewevent
 type PullRequestReviewEvent struct {
 	// Action is always "submitted".
 	Action      *string            `json:"action,omitempty"`
@@ -351,8 +452,9 @@ type PullRequestReviewEvent struct {
 	PullRequest *PullRequest       `json:"pull_request,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 
 	// The following field is only present when the webhook is triggered on
 	// a repository belonging to an organization.
@@ -363,7 +465,7 @@ type PullRequestReviewEvent struct {
 // portion of the unified diff of a pull request.
 // The Webhook event name is "pull_request_review_comment".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#pullrequestreviewcommentevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pullrequestreviewcommentevent
 type PullRequestReviewCommentEvent struct {
 	// Action is the action that was performed on the comment.
 	// Possible values are: "created", "edited", "deleted".
@@ -372,34 +474,36 @@ type PullRequestReviewCommentEvent struct {
 	Comment     *PullRequestComment `json:"comment,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Changes *EditChange `json:"changes,omitempty"`
-	Repo    *Repository `json:"repository,omitempty"`
-	Sender  *User       `json:"sender,omitempty"`
+	Changes      *EditChange   `json:"changes,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // PushEvent represents a git push to a GitHub repository.
 //
-// GitHub API docs: http://developer.github.com/v3/activity/events/types/#pushevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#pushevent
 type PushEvent struct {
-	PushID       *int                 `json:"push_id,omitempty"`
-	Head         *string              `json:"head,omitempty"`
-	Ref          *string              `json:"ref,omitempty"`
-	Size         *int                 `json:"size,omitempty"`
-	Commits      []PushEventCommit    `json:"commits,omitempty"`
-	Repo         *PushEventRepository `json:"repository,omitempty"`
-	Before       *string              `json:"before,omitempty"`
-	DistinctSize *int                 `json:"distinct_size,omitempty"`
+	PushID       *int              `json:"push_id,omitempty"`
+	Head         *string           `json:"head,omitempty"`
+	Ref          *string           `json:"ref,omitempty"`
+	Size         *int              `json:"size,omitempty"`
+	Commits      []PushEventCommit `json:"commits,omitempty"`
+	Before       *string           `json:"before,omitempty"`
+	DistinctSize *int              `json:"distinct_size,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	After      *string          `json:"after,omitempty"`
-	Created    *bool            `json:"created,omitempty"`
-	Deleted    *bool            `json:"deleted,omitempty"`
-	Forced     *bool            `json:"forced,omitempty"`
-	BaseRef    *string          `json:"base_ref,omitempty"`
-	Compare    *string          `json:"compare,omitempty"`
-	HeadCommit *PushEventCommit `json:"head_commit,omitempty"`
-	Pusher     *User            `json:"pusher,omitempty"`
-	Sender     *User            `json:"sender,omitempty"`
+	After        *string              `json:"after,omitempty"`
+	Created      *bool                `json:"created,omitempty"`
+	Deleted      *bool                `json:"deleted,omitempty"`
+	Forced       *bool                `json:"forced,omitempty"`
+	BaseRef      *string              `json:"base_ref,omitempty"`
+	Compare      *string              `json:"compare,omitempty"`
+	Repo         *PushEventRepository `json:"repository,omitempty"`
+	HeadCommit   *PushEventCommit     `json:"head_commit,omitempty"`
+	Pusher       *User                `json:"pusher,omitempty"`
+	Sender       *User                `json:"sender,omitempty"`
+	Installation *Installation        `json:"installation,omitempty"`
 }
 
 func (p PushEvent) String() string {
@@ -430,7 +534,7 @@ func (p PushEventCommit) String() string {
 	return Stringify(p)
 }
 
-// PushEventRepository represents the repo object in a PushEvent payload
+// PushEventRepository represents the repo object in a PushEvent payload.
 type PushEventRepository struct {
 	ID              *int                `json:"id,omitempty"`
 	Name            *string             `json:"name,omitempty"`
@@ -456,13 +560,17 @@ type PushEventRepository struct {
 	DefaultBranch   *string             `json:"default_branch,omitempty"`
 	MasterBranch    *string             `json:"master_branch,omitempty"`
 	Organization    *string             `json:"organization,omitempty"`
-
-	// The following fields are only populated by Webhook events.
-	URL     *string `json:"url,omitempty"`
-	HTMLURL *string `json:"html_url,omitempty"`
+	URL             *string             `json:"url,omitempty"`
+	ArchiveURL      *string             `json:"archive_url,omitempty"`
+	HTMLURL         *string             `json:"html_url,omitempty"`
+	StatusesURL     *string             `json:"statuses_url,omitempty"`
+	GitURL          *string             `json:"git_url,omitempty"`
+	SSHURL          *string             `json:"ssh_url,omitempty"`
+	CloneURL        *string             `json:"clone_url,omitempty"`
+	SVNURL          *string             `json:"svn_url,omitempty"`
 }
 
-// PushEventRepoOwner is a basic reporesntation of user/org in a PushEvent payload
+// PushEventRepoOwner is a basic representation of user/org in a PushEvent payload.
 type PushEventRepoOwner struct {
 	Name  *string `json:"name,omitempty"`
 	Email *string `json:"email,omitempty"`
@@ -471,15 +579,16 @@ type PushEventRepoOwner struct {
 // ReleaseEvent is triggered when a release is published.
 // The Webhook event name is "release".
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#releaseevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#releaseevent
 type ReleaseEvent struct {
 	// Action is the action that was performed. Possible value is: "published".
 	Action  *string            `json:"action,omitempty"`
 	Release *RepositoryRelease `json:"release,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // RepositoryEvent is triggered when a repository is created.
@@ -488,7 +597,7 @@ type ReleaseEvent struct {
 // Events of this type are not visible in timelines, they are only used to
 // trigger organization webhooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#repositoryevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#repositoryevent
 type RepositoryEvent struct {
 	// Action is the action that was performed. Possible values are: "created", "deleted",
 	// "publicized", "privatized".
@@ -496,8 +605,9 @@ type RepositoryEvent struct {
 	Repo   *Repository `json:"repository,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Org    *Organization `json:"organization,omitempty"`
-	Sender *User         `json:"sender,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // StatusEvent is triggered when the status of a Git commit changes.
@@ -506,7 +616,7 @@ type RepositoryEvent struct {
 // Events of this type are not visible in timelines, they are only used to
 // trigger hooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#statusevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#statusevent
 type StatusEvent struct {
 	SHA *string `json:"sha,omitempty"`
 	// State is the new state. Possible values are: "pending", "success", "failure", "error".
@@ -516,14 +626,15 @@ type StatusEvent struct {
 	Branches    []*Branch `json:"branches,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	ID        *int              `json:"id,omitempty"`
-	Name      *string           `json:"name,omitempty"`
-	Context   *string           `json:"context,omitempty"`
-	Commit    *RepositoryCommit `json:"commit,omitempty"`
-	CreatedAt *Timestamp        `json:"created_at,omitempty"`
-	UpdatedAt *Timestamp        `json:"updated_at,omitempty"`
-	Repo      *Repository       `json:"repository,omitempty"`
-	Sender    *User             `json:"sender,omitempty"`
+	ID           *int              `json:"id,omitempty"`
+	Name         *string           `json:"name,omitempty"`
+	Context      *string           `json:"context,omitempty"`
+	Commit       *RepositoryCommit `json:"commit,omitempty"`
+	CreatedAt    *Timestamp        `json:"created_at,omitempty"`
+	UpdatedAt    *Timestamp        `json:"updated_at,omitempty"`
+	Repo         *Repository       `json:"repository,omitempty"`
+	Sender       *User             `json:"sender,omitempty"`
+	Installation *Installation     `json:"installation,omitempty"`
 }
 
 // TeamAddEvent is triggered when a repository is added to a team.
@@ -532,14 +643,15 @@ type StatusEvent struct {
 // Events of this type are not visible in timelines. These events are only used
 // to trigger hooks.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#teamaddevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#teamaddevent
 type TeamAddEvent struct {
 	Team *Team       `json:"team,omitempty"`
 	Repo *Repository `json:"repository,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Org    *Organization `json:"organization,omitempty"`
-	Sender *User         `json:"sender,omitempty"`
+	Org          *Organization `json:"organization,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }
 
 // WatchEvent is related to starring a repository, not watching. See this API
@@ -548,12 +660,13 @@ type TeamAddEvent struct {
 // The event’s actor is the user who starred a repository, and the event’s
 // repository is the repository that was starred.
 //
-// GitHub docs: https://developer.github.com/v3/activity/events/types/#watchevent
+// GitHub API docs: https://developer.github.com/v3/activity/events/types/#watchevent
 type WatchEvent struct {
 	// Action is the action that was performed. Possible value is: "started".
 	Action *string `json:"action,omitempty"`
 
 	// The following fields are only populated by Webhook events.
-	Repo   *Repository `json:"repository,omitempty"`
-	Sender *User       `json:"sender,omitempty"`
+	Repo         *Repository   `json:"repository,omitempty"`
+	Sender       *User         `json:"sender,omitempty"`
+	Installation *Installation `json:"installation,omitempty"`
 }

vendor/github.com/google/go-github/github/gen-accessors.go

@@ -0,0 +1,299 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// gen-accessors generates accessor methods for structs with pointer fields.
+//
+// It is meant to be used by the go-github authors in conjunction with the
+// go generate tool before sending a commit to GitHub.
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"log"
+	"os"
+	"sort"
+	"strings"
+	"text/template"
+	"time"
+)
+
+const (
+	fileSuffix = "-accessors.go"
+)
+
+var (
+	verbose = flag.Bool("v", false, "Print verbose log messages")
+
+	sourceTmpl = template.Must(template.New("source").Parse(source))
+
+	// blacklist lists which "struct.method" combos to not generate.
+	blacklist = map[string]bool{
+		"RepositoryContent.GetContent":    true,
+		"Client.GetBaseURL":               true,
+		"Client.GetUploadURL":             true,
+		"ErrorResponse.GetResponse":       true,
+		"RateLimitError.GetResponse":      true,
+		"AbuseRateLimitError.GetResponse": true,
+	}
+)
+
+func logf(fmt string, args ...interface{}) {
+	if *verbose {
+		log.Printf(fmt, args...)
+	}
+}
+
+func main() {
+	flag.Parse()
+	fset := token.NewFileSet()
+
+	pkgs, err := parser.ParseDir(fset, ".", sourceFilter, 0)
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+
+	for pkgName, pkg := range pkgs {
+		t := &templateData{
+			filename: pkgName + fileSuffix,
+			Year:     time.Now().Year(),
+			Package:  pkgName,
+			Imports:  map[string]string{},
+		}
+		for filename, f := range pkg.Files {
+			logf("Processing %v...", filename)
+			if err := t.processAST(f); err != nil {
+				log.Fatal(err)
+			}
+		}
+		if err := t.dump(); err != nil {
+			log.Fatal(err)
+		}
+	}
+	logf("Done.")
+}
+
+func (t *templateData) processAST(f *ast.File) error {
+	for _, decl := range f.Decls {
+		gd, ok := decl.(*ast.GenDecl)
+		if !ok {
+			continue
+		}
+		for _, spec := range gd.Specs {
+			ts, ok := spec.(*ast.TypeSpec)
+			if !ok {
+				continue
+			}
+			st, ok := ts.Type.(*ast.StructType)
+			if !ok {
+				continue
+			}
+			for _, field := range st.Fields.List {
+				se, ok := field.Type.(*ast.StarExpr)
+				if len(field.Names) == 0 || !ok {
+					continue
+				}
+
+				fieldName := field.Names[0]
+				if key := fmt.Sprintf("%v.Get%v", ts.Name, fieldName); blacklist[key] {
+					logf("Method %v blacklisted; skipping.", key)
+					continue
+				}
+
+				switch x := se.X.(type) {
+				case *ast.ArrayType:
+					t.addArrayType(x, ts.Name.String(), fieldName.String())
+				case *ast.Ident:
+					t.addIdent(x, ts.Name.String(), fieldName.String())
+				case *ast.MapType:
+					t.addMapType(x, ts.Name.String(), fieldName.String())
+				case *ast.SelectorExpr:
+					t.addSelectorExpr(x, ts.Name.String(), fieldName.String())
+				default:
+					logf("processAST: type %q, field %q, unknown %T: %+v", ts.Name, fieldName, x, x)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func sourceFilter(fi os.FileInfo) bool {
+	return !strings.HasSuffix(fi.Name(), "_test.go") && !strings.HasSuffix(fi.Name(), fileSuffix)
+}
+
+func (t *templateData) dump() error {
+	if len(t.Getters) == 0 {
+		logf("No getters for %v; skipping.", t.filename)
+		return nil
+	}
+
+	// Sort getters by ReceiverType.FieldName
+	sort.Sort(byName(t.Getters))
+
+	var buf bytes.Buffer
+	if err := sourceTmpl.Execute(&buf, t); err != nil {
+		return err
+	}
+	clean, err := format.Source(buf.Bytes())
+	if err != nil {
+		return err
+	}
+
+	logf("Writing %v...", t.filename)
+	return ioutil.WriteFile(t.filename, clean, 0644)
+}
+
+func newGetter(receiverType, fieldName, fieldType, zeroValue string) *getter {
+	return &getter{
+		sortVal:      strings.ToLower(receiverType) + "." + strings.ToLower(fieldName),
+		ReceiverVar:  strings.ToLower(receiverType[:1]),
+		ReceiverType: receiverType,
+		FieldName:    fieldName,
+		FieldType:    fieldType,
+		ZeroValue:    zeroValue,
+	}
+}
+
+func (t *templateData) addArrayType(x *ast.ArrayType, receiverType, fieldName string) {
+	var eltType string
+	switch elt := x.Elt.(type) {
+	case *ast.Ident:
+		eltType = elt.String()
+	default:
+		logf("addArrayType: type %q, field %q: unknown elt type: %T %+v; skipping.", receiverType, fieldName, elt, elt)
+		return
+	}
+
+	t.Getters = append(t.Getters, newGetter(receiverType, fieldName, "[]"+eltType, "nil"))
+}
+
+func (t *templateData) addIdent(x *ast.Ident, receiverType, fieldName string) {
+	var zeroValue string
+	switch x.String() {
+	case "int":
+		zeroValue = "0"
+	case "string":
+		zeroValue = `""`
+	case "bool":
+		zeroValue = "false"
+	case "Timestamp":
+		zeroValue = "Timestamp{}"
+	default: // other structs handled by their receivers directly.
+		return
+	}
+
+	t.Getters = append(t.Getters, newGetter(receiverType, fieldName, x.String(), zeroValue))
+}
+
+func (t *templateData) addMapType(x *ast.MapType, receiverType, fieldName string) {
+	var keyType string
+	switch key := x.Key.(type) {
+	case *ast.Ident:
+		keyType = key.String()
+	default:
+		logf("addMapType: type %q, field %q: unknown key type: %T %+v; skipping.", receiverType, fieldName, key, key)
+		return
+	}
+
+	var valueType string
+	switch value := x.Value.(type) {
+	case *ast.Ident:
+		valueType = value.String()
+	default:
+		logf("addMapType: type %q, field %q: unknown value type: %T %+v; skipping.", receiverType, fieldName, value, value)
+		return
+	}
+
+	fieldType := fmt.Sprintf("map[%v]%v", keyType, valueType)
+	zeroValue := fmt.Sprintf("map[%v]%v{}", keyType, valueType)
+	t.Getters = append(t.Getters, newGetter(receiverType, fieldName, fieldType, zeroValue))
+}
+
+func (t *templateData) addSelectorExpr(x *ast.SelectorExpr, receiverType, fieldName string) {
+	if strings.ToLower(fieldName[:1]) == fieldName[:1] { // non-exported field
+		return
+	}
+
+	var xX string
+	if xx, ok := x.X.(*ast.Ident); ok {
+		xX = xx.String()
+	}
+
+	switch xX {
+	case "time", "json":
+		if xX == "json" {
+			t.Imports["encoding/json"] = "encoding/json"
+		} else {
+			t.Imports[xX] = xX
+		}
+		fieldType := fmt.Sprintf("%v.%v", xX, x.Sel.Name)
+		zeroValue := fmt.Sprintf("%v.%v{}", xX, x.Sel.Name)
+		if xX == "time" && x.Sel.Name == "Duration" {
+			zeroValue = "0"
+		}
+		t.Getters = append(t.Getters, newGetter(receiverType, fieldName, fieldType, zeroValue))
+	default:
+		logf("addSelectorExpr: xX %q, type %q, field %q: unknown x=%+v; skipping.", xX, receiverType, fieldName, x)
+	}
+}
+
+type templateData struct {
+	filename string
+	Year     int
+	Package  string
+	Imports  map[string]string
+	Getters  []*getter
+}
+
+type getter struct {
+	sortVal      string // lower-case version of "ReceiverType.FieldName"
+	ReceiverVar  string // the one-letter variable name to match the ReceiverType
+	ReceiverType string
+	FieldName    string
+	FieldType    string
+	ZeroValue    string
+}
+
+type byName []*getter
+
+func (b byName) Len() int           { return len(b) }
+func (b byName) Less(i, j int) bool { return b[i].sortVal < b[j].sortVal }
+func (b byName) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+
+const source = `// Copyright {{.Year}} The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated by gen-accessors; DO NOT EDIT.
+
+package {{.Package}}
+{{with .Imports}}
+import (
+  {{- range . -}}
+  "{{.}}"
+  {{end -}}
+)
+{{end}}
+{{range .Getters}}
+// Get{{.FieldName}} returns the {{.FieldName}} field if it's non-nil, zero value otherwise.
+func ({{.ReceiverVar}} *{{.ReceiverType}}) Get{{.FieldName}}() {{.FieldType}} {
+  if {{.ReceiverVar}} == nil || {{.ReceiverVar}}.{{.FieldName}} == nil {
+    return {{.ZeroValue}}
+  }
+  return *{{.ReceiverVar}}.{{.FieldName}}
+}
+{{end}}
+`

vendor/github.com/google/go-github/github/gists.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -13,7 +14,7 @@ import (
 // GistsService handles communication with the Gist related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/
+// GitHub API docs: https://developer.github.com/v3/gists/
 type GistsService service
 
 // Gist represents a GitHub's gist.
@@ -42,6 +43,7 @@ type GistFilename string
 type GistFile struct {
 	Size     *int    `json:"size,omitempty"`
 	Filename *string `json:"filename,omitempty"`
+	Language *string `json:"language,omitempty"`
 	Type     *string `json:"type,omitempty"`
 	RawURL   *string `json:"raw_url,omitempty"`
 	Content  *string `json:"content,omitempty"`
@@ -57,7 +59,7 @@ type GistCommit struct {
 	Version      *string      `json:"version,omitempty"`
 	User         *User        `json:"user,omitempty"`
 	ChangeStatus *CommitStats `json:"change_status,omitempty"`
-	CommitedAt   *Timestamp   `json:"commited_at,omitempty"`
+	CommittedAt  *Timestamp   `json:"committed_at,omitempty"`
 }
 
 func (gc GistCommit) String() string {
@@ -91,8 +93,8 @@ type GistListOptions struct {
 // is authenticated, it will returns all gists for the authenticated
 // user.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#list-gists
-func (s *GistsService) List(user string, opt *GistListOptions) ([]*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#list-gists
+func (s *GistsService) List(ctx context.Context, user string, opt *GistListOptions) ([]*Gist, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/gists", user)
@@ -109,19 +111,19 @@ func (s *GistsService) List(user string, opt *GistListOptions) ([]*Gist, *Respon
 		return nil, nil, err
 	}
 
-	gists := new([]*Gist)
-	resp, err := s.client.Do(req, gists)
+	var gists []*Gist
+	resp, err := s.client.Do(ctx, req, &gists)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *gists, resp, err
+	return gists, resp, nil
 }
 
 // ListAll lists all public gists.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#list-gists
-func (s *GistsService) ListAll(opt *GistListOptions) ([]*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#list-gists
+func (s *GistsService) ListAll(ctx context.Context, opt *GistListOptions) ([]*Gist, *Response, error) {
 	u, err := addOptions("gists/public", opt)
 	if err != nil {
 		return nil, nil, err
@@ -132,19 +134,19 @@ func (s *GistsService) ListAll(opt *GistListOptions) ([]*Gist, *Response, error)
 		return nil, nil, err
 	}
 
-	gists := new([]*Gist)
-	resp, err := s.client.Do(req, gists)
+	var gists []*Gist
+	resp, err := s.client.Do(ctx, req, &gists)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *gists, resp, err
+	return gists, resp, nil
 }
 
 // ListStarred lists starred gists of authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#list-gists
-func (s *GistsService) ListStarred(opt *GistListOptions) ([]*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#list-gists
+func (s *GistsService) ListStarred(ctx context.Context, opt *GistListOptions) ([]*Gist, *Response, error) {
 	u, err := addOptions("gists/starred", opt)
 	if err != nil {
 		return nil, nil, err
@@ -155,160 +157,160 @@ func (s *GistsService) ListStarred(opt *GistListOptions) ([]*Gist, *Response, er
 		return nil, nil, err
 	}
 
-	gists := new([]*Gist)
-	resp, err := s.client.Do(req, gists)
+	var gists []*Gist
+	resp, err := s.client.Do(ctx, req, &gists)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *gists, resp, err
+	return gists, resp, nil
 }
 
 // Get a single gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#get-a-single-gist
-func (s *GistsService) Get(id string) (*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#get-a-single-gist
+func (s *GistsService) Get(ctx context.Context, id string) (*Gist, *Response, error) {
 	u := fmt.Sprintf("gists/%v", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 	gist := new(Gist)
-	resp, err := s.client.Do(req, gist)
+	resp, err := s.client.Do(ctx, req, gist)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return gist, resp, err
+	return gist, resp, nil
 }
 
 // GetRevision gets a specific revision of a gist.
 //
 // GitHub API docs: https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist
-func (s *GistsService) GetRevision(id, sha string) (*Gist, *Response, error) {
+func (s *GistsService) GetRevision(ctx context.Context, id, sha string) (*Gist, *Response, error) {
 	u := fmt.Sprintf("gists/%v/%v", id, sha)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 	gist := new(Gist)
-	resp, err := s.client.Do(req, gist)
+	resp, err := s.client.Do(ctx, req, gist)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return gist, resp, err
+	return gist, resp, nil
 }
 
 // Create a gist for authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#create-a-gist
-func (s *GistsService) Create(gist *Gist) (*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#create-a-gist
+func (s *GistsService) Create(ctx context.Context, gist *Gist) (*Gist, *Response, error) {
 	u := "gists"
 	req, err := s.client.NewRequest("POST", u, gist)
 	if err != nil {
 		return nil, nil, err
 	}
 	g := new(Gist)
-	resp, err := s.client.Do(req, g)
+	resp, err := s.client.Do(ctx, req, g)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return g, resp, err
+	return g, resp, nil
 }
 
 // Edit a gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#edit-a-gist
-func (s *GistsService) Edit(id string, gist *Gist) (*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#edit-a-gist
+func (s *GistsService) Edit(ctx context.Context, id string, gist *Gist) (*Gist, *Response, error) {
 	u := fmt.Sprintf("gists/%v", id)
 	req, err := s.client.NewRequest("PATCH", u, gist)
 	if err != nil {
 		return nil, nil, err
 	}
 	g := new(Gist)
-	resp, err := s.client.Do(req, g)
+	resp, err := s.client.Do(ctx, req, g)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return g, resp, err
+	return g, resp, nil
 }
 
 // ListCommits lists commits of a gist.
 //
-// Github API docs: https://developer.github.com/v3/gists/#list-gist-commits
-func (s *GistsService) ListCommits(id string) ([]*GistCommit, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#list-gist-commits
+func (s *GistsService) ListCommits(ctx context.Context, id string) ([]*GistCommit, *Response, error) {
 	u := fmt.Sprintf("gists/%v/commits", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	gistCommits := new([]*GistCommit)
-	resp, err := s.client.Do(req, gistCommits)
+	var gistCommits []*GistCommit
+	resp, err := s.client.Do(ctx, req, &gistCommits)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *gistCommits, resp, err
+	return gistCommits, resp, nil
 }
 
 // Delete a gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#delete-a-gist
-func (s *GistsService) Delete(id string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#delete-a-gist
+func (s *GistsService) Delete(ctx context.Context, id string) (*Response, error) {
 	u := fmt.Sprintf("gists/%v", id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Star a gist on behalf of authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#star-a-gist
-func (s *GistsService) Star(id string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#star-a-gist
+func (s *GistsService) Star(ctx context.Context, id string) (*Response, error) {
 	u := fmt.Sprintf("gists/%v/star", id)
 	req, err := s.client.NewRequest("PUT", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Unstar a gist on a behalf of authenticated user.
 //
-// Github API docs: http://developer.github.com/v3/gists/#unstar-a-gist
-func (s *GistsService) Unstar(id string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#unstar-a-gist
+func (s *GistsService) Unstar(ctx context.Context, id string) (*Response, error) {
 	u := fmt.Sprintf("gists/%v/star", id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // IsStarred checks if a gist is starred by authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#check-if-a-gist-is-starred
-func (s *GistsService) IsStarred(id string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#check-if-a-gist-is-starred
+func (s *GistsService) IsStarred(ctx context.Context, id string) (bool, *Response, error) {
 	u := fmt.Sprintf("gists/%v/star", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	starred, err := parseBoolResponse(err)
 	return starred, resp, err
 }
 
 // Fork a gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/#fork-a-gist
-func (s *GistsService) Fork(id string) (*Gist, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#fork-a-gist
+func (s *GistsService) Fork(ctx context.Context, id string) (*Gist, *Response, error) {
 	u := fmt.Sprintf("gists/%v/forks", id)
 	req, err := s.client.NewRequest("POST", u, nil)
 	if err != nil {
@@ -316,29 +318,29 @@ func (s *GistsService) Fork(id string) (*Gist, *Response, error) {
 	}
 
 	g := new(Gist)
-	resp, err := s.client.Do(req, g)
+	resp, err := s.client.Do(ctx, req, g)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return g, resp, err
+	return g, resp, nil
 }
 
 // ListForks lists forks of a gist.
 //
-// Github API docs: https://developer.github.com/v3/gists/#list-gist-forks
-func (s *GistsService) ListForks(id string) ([]*GistFork, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/#list-gist-forks
+func (s *GistsService) ListForks(ctx context.Context, id string) ([]*GistFork, *Response, error) {
 	u := fmt.Sprintf("gists/%v/forks", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	gistForks := new([]*GistFork)
-	resp, err := s.client.Do(req, gistForks)
+	var gistForks []*GistFork
+	resp, err := s.client.Do(ctx, req, &gistForks)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *gistForks, resp, err
+	return gistForks, resp, nil
 }

vendor/github.com/google/go-github/github/gists_comments.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -25,8 +26,8 @@ func (g GistComment) String() string {
 
 // ListComments lists all comments for a gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/comments/#list-comments-on-a-gist
-func (s *GistsService) ListComments(gistID string, opt *ListOptions) ([]*GistComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist
+func (s *GistsService) ListComments(ctx context.Context, gistID string, opt *ListOptions) ([]*GistComment, *Response, error) {
 	u := fmt.Sprintf("gists/%v/comments", gistID)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -38,19 +39,19 @@ func (s *GistsService) ListComments(gistID string, opt *ListOptions) ([]*GistCom
 		return nil, nil, err
 	}
 
-	comments := new([]*GistComment)
-	resp, err := s.client.Do(req, comments)
+	var comments []*GistComment
+	resp, err := s.client.Do(ctx, req, &comments)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *comments, resp, err
+	return comments, resp, nil
 }
 
 // GetComment retrieves a single comment from a gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/comments/#get-a-single-comment
-func (s *GistsService) GetComment(gistID string, commentID int) (*GistComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/comments/#get-a-single-comment
+func (s *GistsService) GetComment(ctx context.Context, gistID string, commentID int) (*GistComment, *Response, error) {
 	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -58,18 +59,18 @@ func (s *GistsService) GetComment(gistID string, commentID int) (*GistComment, *
 	}
 
 	c := new(GistComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // CreateComment creates a comment for a gist.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/comments/#create-a-comment
-func (s *GistsService) CreateComment(gistID string, comment *GistComment) (*GistComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/comments/#create-a-comment
+func (s *GistsService) CreateComment(ctx context.Context, gistID string, comment *GistComment) (*GistComment, *Response, error) {
 	u := fmt.Sprintf("gists/%v/comments", gistID)
 	req, err := s.client.NewRequest("POST", u, comment)
 	if err != nil {
@@ -77,18 +78,18 @@ func (s *GistsService) CreateComment(gistID string, comment *GistComment) (*Gist
 	}
 
 	c := new(GistComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // EditComment edits an existing gist comment.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/comments/#edit-a-comment
-func (s *GistsService) EditComment(gistID string, commentID int, comment *GistComment) (*GistComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/comments/#edit-a-comment
+func (s *GistsService) EditComment(ctx context.Context, gistID string, commentID int, comment *GistComment) (*GistComment, *Response, error) {
 	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
 	req, err := s.client.NewRequest("PATCH", u, comment)
 	if err != nil {
@@ -96,23 +97,23 @@ func (s *GistsService) EditComment(gistID string, commentID int, comment *GistCo
 	}
 
 	c := new(GistComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // DeleteComment deletes a gist comment.
 //
-// GitHub API docs: http://developer.github.com/v3/gists/comments/#delete-a-comment
-func (s *GistsService) DeleteComment(gistID string, commentID int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gists/comments/#delete-a-comment
+func (s *GistsService) DeleteComment(ctx context.Context, gistID string, commentID int) (*Response, error) {
 	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/git.go

@@ -8,5 +8,5 @@ package github
 // GitService handles communication with the git data related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/git/
+// GitHub API docs: https://developer.github.com/v3/git/
 type GitService service

vendor/github.com/google/go-github/github/git_blobs.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Blob represents a blob object.
 type Blob struct {
@@ -18,8 +21,8 @@ type Blob struct {
 
 // GetBlob fetchs a blob from a repo given a SHA.
 //
-// GitHub API docs: http://developer.github.com/v3/git/blobs/#get-a-blob
-func (s *GitService) GetBlob(owner string, repo string, sha string) (*Blob, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/blobs/#get-a-blob
+func (s *GitService) GetBlob(ctx context.Context, owner string, repo string, sha string) (*Blob, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -27,14 +30,14 @@ func (s *GitService) GetBlob(owner string, repo string, sha string) (*Blob, *Res
 	}
 
 	blob := new(Blob)
-	resp, err := s.client.Do(req, blob)
+	resp, err := s.client.Do(ctx, req, blob)
 	return blob, resp, err
 }
 
 // CreateBlob creates a blob object.
 //
 // GitHub API docs: https://developer.github.com/v3/git/blobs/#create-a-blob
-func (s *GitService) CreateBlob(owner string, repo string, blob *Blob) (*Blob, *Response, error) {
+func (s *GitService) CreateBlob(ctx context.Context, owner string, repo string, blob *Blob) (*Blob, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/blobs", owner, repo)
 	req, err := s.client.NewRequest("POST", u, blob)
 	if err != nil {
@@ -42,6 +45,6 @@ func (s *GitService) CreateBlob(owner string, repo string, blob *Blob) (*Blob, *
 	}
 
 	t := new(Blob)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	return t, resp, err
 }

vendor/github.com/google/go-github/github/git_commits.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -27,10 +28,11 @@ type Commit struct {
 	Tree         *Tree                  `json:"tree,omitempty"`
 	Parents      []Commit               `json:"parents,omitempty"`
 	Stats        *CommitStats           `json:"stats,omitempty"`
+	HTMLURL      *string                `json:"html_url,omitempty"`
 	URL          *string                `json:"url,omitempty"`
 	Verification *SignatureVerification `json:"verification,omitempty"`
 
-	// CommentCount is the number of GitHub comments on the commit.  This
+	// CommentCount is the number of GitHub comments on the commit. This
 	// is only populated for requests that fetch GitHub data like
 	// Pulls.ListCommits, Repositories.ListCommits, etc.
 	CommentCount *int `json:"comment_count,omitempty"`
@@ -40,7 +42,7 @@ func (c Commit) String() string {
 	return Stringify(c)
 }
 
-// CommitAuthor represents the author or committer of a commit.  The commit
+// CommitAuthor represents the author or committer of a commit. The commit
 // author may not correspond to a GitHub User.
 type CommitAuthor struct {
 	Date  *time.Time `json:"date,omitempty"`
@@ -57,8 +59,8 @@ func (c CommitAuthor) String() string {
 
 // GetCommit fetchs the Commit object for a given SHA.
 //
-// GitHub API docs: http://developer.github.com/v3/git/commits/#get-a-commit
-func (s *GitService) GetCommit(owner string, repo string, sha string) (*Commit, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/commits/#get-a-commit
+func (s *GitService) GetCommit(ctx context.Context, owner string, repo string, sha string) (*Commit, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/commits/%v", owner, repo, sha)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -69,12 +71,12 @@ func (s *GitService) GetCommit(owner string, repo string, sha string) (*Commit,
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
 	c := new(Commit)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // createCommit represents the body of a CreateCommit request.
@@ -87,29 +89,33 @@ type createCommit struct {
 }
 
 // CreateCommit creates a new commit in a repository.
+// commit must not be nil.
 //
 // The commit.Committer is optional and will be filled with the commit.Author
 // data if omitted. If the commit.Author is omitted, it will be filled in with
 // the authenticated user’s information and the current date.
 //
-// GitHub API docs: http://developer.github.com/v3/git/commits/#create-a-commit
-func (s *GitService) CreateCommit(owner string, repo string, commit *Commit) (*Commit, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/commits/#create-a-commit
+func (s *GitService) CreateCommit(ctx context.Context, owner string, repo string, commit *Commit) (*Commit, *Response, error) {
+	if commit == nil {
+		return nil, nil, fmt.Errorf("commit must be provided")
+	}
+
 	u := fmt.Sprintf("repos/%v/%v/git/commits", owner, repo)
 
-	body := &createCommit{}
-	if commit != nil {
-		parents := make([]string, len(commit.Parents))
-		for i, parent := range commit.Parents {
-			parents[i] = *parent.SHA
-		}
+	parents := make([]string, len(commit.Parents))
+	for i, parent := range commit.Parents {
+		parents[i] = *parent.SHA
+	}
 
-		body = &createCommit{
-			Author:    commit.Author,
-			Committer: commit.Committer,
-			Message:   commit.Message,
-			Tree:      commit.Tree.SHA,
-			Parents:   parents,
-		}
+	body := &createCommit{
+		Author:    commit.Author,
+		Committer: commit.Committer,
+		Message:   commit.Message,
+		Parents:   parents,
+	}
+	if commit.Tree != nil {
+		body.Tree = commit.Tree.SHA
 	}
 
 	req, err := s.client.NewRequest("POST", u, body)
@@ -118,10 +124,10 @@ func (s *GitService) CreateCommit(owner string, repo string, commit *Commit) (*C
 	}
 
 	c := new(Commit)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }

vendor/github.com/google/go-github/github/git_refs.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"strings"
 )
@@ -46,8 +47,8 @@ type updateRefRequest struct {
 
 // GetRef fetches the Reference object for a given Git ref.
 //
-// GitHub API docs: http://developer.github.com/v3/git/refs/#get-a-reference
-func (s *GitService) GetRef(owner string, repo string, ref string) (*Reference, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/refs/#get-a-reference
+func (s *GitService) GetRef(ctx context.Context, owner string, repo string, ref string) (*Reference, *Response, error) {
 	ref = strings.TrimPrefix(ref, "refs/")
 	u := fmt.Sprintf("repos/%v/%v/git/refs/%v", owner, repo, ref)
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -56,12 +57,12 @@ func (s *GitService) GetRef(owner string, repo string, ref string) (*Reference,
 	}
 
 	r := new(Reference)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r, resp, err
+	return r, resp, nil
 }
 
 // ReferenceListOptions specifies optional parameters to the
@@ -74,8 +75,8 @@ type ReferenceListOptions struct {
 
 // ListRefs lists all refs in a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/git/refs/#get-all-references
-func (s *GitService) ListRefs(owner, repo string, opt *ReferenceListOptions) ([]*Reference, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/refs/#get-all-references
+func (s *GitService) ListRefs(ctx context.Context, owner, repo string, opt *ReferenceListOptions) ([]*Reference, *Response, error) {
 	var u string
 	if opt != nil && opt.Type != "" {
 		u = fmt.Sprintf("repos/%v/%v/git/refs/%v", owner, repo, opt.Type)
@@ -93,18 +94,18 @@ func (s *GitService) ListRefs(owner, repo string, opt *ReferenceListOptions) ([]
 	}
 
 	var rs []*Reference
-	resp, err := s.client.Do(req, &rs)
+	resp, err := s.client.Do(ctx, req, &rs)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return rs, resp, err
+	return rs, resp, nil
 }
 
 // CreateRef creates a new ref in a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/git/refs/#create-a-reference
-func (s *GitService) CreateRef(owner string, repo string, ref *Reference) (*Reference, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/refs/#create-a-reference
+func (s *GitService) CreateRef(ctx context.Context, owner string, repo string, ref *Reference) (*Reference, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/refs", owner, repo)
 	req, err := s.client.NewRequest("POST", u, &createRefRequest{
 		// back-compat with previous behavior that didn't require 'refs/' prefix
@@ -116,18 +117,18 @@ func (s *GitService) CreateRef(owner string, repo string, ref *Reference) (*Refe
 	}
 
 	r := new(Reference)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r, resp, err
+	return r, resp, nil
 }
 
 // UpdateRef updates an existing ref in a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/git/refs/#update-a-reference
-func (s *GitService) UpdateRef(owner string, repo string, ref *Reference, force bool) (*Reference, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/refs/#update-a-reference
+func (s *GitService) UpdateRef(ctx context.Context, owner string, repo string, ref *Reference, force bool) (*Reference, *Response, error) {
 	refPath := strings.TrimPrefix(*ref.Ref, "refs/")
 	u := fmt.Sprintf("repos/%v/%v/git/refs/%v", owner, repo, refPath)
 	req, err := s.client.NewRequest("PATCH", u, &updateRefRequest{
@@ -139,18 +140,18 @@ func (s *GitService) UpdateRef(owner string, repo string, ref *Reference, force
 	}
 
 	r := new(Reference)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r, resp, err
+	return r, resp, nil
 }
 
 // DeleteRef deletes a ref from a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/git/refs/#delete-a-reference
-func (s *GitService) DeleteRef(owner string, repo string, ref string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/refs/#delete-a-reference
+func (s *GitService) DeleteRef(ctx context.Context, owner string, repo string, ref string) (*Response, error) {
 	ref = strings.TrimPrefix(ref, "refs/")
 	u := fmt.Sprintf("repos/%v/%v/git/refs/%v", owner, repo, ref)
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -158,5 +159,5 @@ func (s *GitService) DeleteRef(owner string, repo string, ref string) (*Response
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/git_tags.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 )
 
@@ -20,7 +21,7 @@ type Tag struct {
 	Verification *SignatureVerification `json:"verification,omitempty"`
 }
 
-// createTagRequest represents the body of a CreateTag request.  This is mostly
+// createTagRequest represents the body of a CreateTag request. This is mostly
 // identical to Tag with the exception that the object SHA and Type are
 // top-level fields, rather than being nested inside a JSON object.
 type createTagRequest struct {
@@ -33,8 +34,8 @@ type createTagRequest struct {
 
 // GetTag fetchs a tag from a repo given a SHA.
 //
-// GitHub API docs: http://developer.github.com/v3/git/tags/#get-a-tag
-func (s *GitService) GetTag(owner string, repo string, sha string) (*Tag, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/tags/#get-a-tag
+func (s *GitService) GetTag(ctx context.Context, owner string, repo string, sha string) (*Tag, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/tags/%v", owner, repo, sha)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -45,14 +46,14 @@ func (s *GitService) GetTag(owner string, repo string, sha string) (*Tag, *Respo
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
 	tag := new(Tag)
-	resp, err := s.client.Do(req, tag)
+	resp, err := s.client.Do(ctx, req, tag)
 	return tag, resp, err
 }
 
 // CreateTag creates a tag object.
 //
-// GitHub API docs: http://developer.github.com/v3/git/tags/#create-a-tag-object
-func (s *GitService) CreateTag(owner string, repo string, tag *Tag) (*Tag, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/tags/#create-a-tag-object
+func (s *GitService) CreateTag(ctx context.Context, owner string, repo string, tag *Tag) (*Tag, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/tags", owner, repo)
 
 	// convert Tag into a createTagRequest
@@ -72,6 +73,6 @@ func (s *GitService) CreateTag(owner string, repo string, tag *Tag) (*Tag, *Resp
 	}
 
 	t := new(Tag)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	return t, resp, err
 }

vendor/github.com/google/go-github/github/git_trees.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Tree represents a GitHub tree.
 type Tree struct {
@@ -17,7 +20,7 @@ func (t Tree) String() string {
 	return Stringify(t)
 }
 
-// TreeEntry represents the contents of a tree structure.  TreeEntry can
+// TreeEntry represents the contents of a tree structure. TreeEntry can
 // represent either a blob, a commit (in the case of a submodule), or another
 // tree.
 type TreeEntry struct {
@@ -35,8 +38,8 @@ func (t TreeEntry) String() string {
 
 // GetTree fetches the Tree object for a given sha hash from a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/git/trees/#get-a-tree
-func (s *GitService) GetTree(owner string, repo string, sha string, recursive bool) (*Tree, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/trees/#get-a-tree
+func (s *GitService) GetTree(ctx context.Context, owner string, repo string, sha string, recursive bool) (*Tree, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/trees/%v", owner, repo, sha)
 	if recursive {
 		u += "?recursive=1"
@@ -48,12 +51,12 @@ func (s *GitService) GetTree(owner string, repo string, sha string, recursive bo
 	}
 
 	t := new(Tree)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }
 
 // createTree represents the body of a CreateTree request.
@@ -62,12 +65,12 @@ type createTree struct {
 	Entries  []TreeEntry `json:"tree"`
 }
 
-// CreateTree creates a new tree in a repository.  If both a tree and a nested
+// CreateTree creates a new tree in a repository. If both a tree and a nested
 // path modifying that tree are specified, it will overwrite the contents of
 // that tree with the new path contents and write a new tree out.
 //
-// GitHub API docs: http://developer.github.com/v3/git/trees/#create-a-tree
-func (s *GitService) CreateTree(owner string, repo string, baseTree string, entries []TreeEntry) (*Tree, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/git/trees/#create-a-tree
+func (s *GitService) CreateTree(ctx context.Context, owner string, repo string, baseTree string, entries []TreeEntry) (*Tree, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/git/trees", owner, repo)
 
 	body := &createTree{
@@ -80,10 +83,10 @@ func (s *GitService) CreateTree(owner string, repo string, baseTree string, entr
 	}
 
 	t := new(Tree)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }

vendor/github.com/google/go-github/github/github.go

@@ -3,10 +3,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:generate go run gen-accessors.go
+
 package github
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -24,12 +27,7 @@ import (
 )
 
 const (
-	// StatusUnprocessableEntity is the status code returned when sending a request with invalid fields.
-	StatusUnprocessableEntity = 422
-)
-
-const (
-	libraryVersion = "2"
+	libraryVersion = "6"
 	defaultBaseURL = "https://api.github.com/"
 	uploadBaseURL  = "https://uploads.github.com/"
 	userAgent      = "go-github/" + libraryVersion
@@ -85,14 +83,20 @@ const (
 	// https://developer.github.com/changes/2016-07-06-github-pages-preiew-api/
 	mediaTypePagesPreview = "application/vnd.github.mister-fantastic-preview+json"
 
-	// https://developer.github.com/v3/repos/traffic/
-	mediaTypeTrafficPreview = "application/vnd.github.spiderman-preview+json"
-
 	// https://developer.github.com/changes/2016-09-14-projects-api/
 	mediaTypeProjectsPreview = "application/vnd.github.inertia-preview+json"
 
 	// https://developer.github.com/changes/2016-09-14-Integrations-Early-Access/
 	mediaTypeIntegrationPreview = "application/vnd.github.machine-man-preview+json"
+
+	// https://developer.github.com/changes/2017-01-05-commit-search-api/
+	mediaTypeCommitSearchPreview = "application/vnd.github.cloak-preview+json"
+
+	// https://developer.github.com/changes/2016-12-14-reviews-api/
+	mediaTypePullRequestReviewsPreview = "application/vnd.github.black-cat-preview+json"
+
+	// https://developer.github.com/changes/2017-02-28-user-blocking-apis-and-webhook/
+	mediaTypeBlockUsersPreview = "application/vnd.github.giant-sentry-fist-preview+json"
 )
 
 // A Client manages communication with the GitHub API.
@@ -100,8 +104,8 @@ type Client struct {
 	clientMu sync.Mutex   // clientMu protects the client during calls that modify the CheckRedirect func.
 	client   *http.Client // HTTP client used to communicate with the API.
 
-	// Base URL for API requests.  Defaults to the public GitHub API, but can be
-	// set to a domain endpoint to use with GitHub Enterprise.  BaseURL should
+	// Base URL for API requests. Defaults to the public GitHub API, but can be
+	// set to a domain endpoint to use with GitHub Enterprise. BaseURL should
 	// always be specified with a trailing slash.
 	BaseURL *url.URL
 
@@ -113,7 +117,6 @@ type Client struct {
 
 	rateMu     sync.Mutex
 	rateLimits [categories]Rate // Rate limits for the client as determined by the most recent API calls.
-	mostRecent rateLimitCategory
 
 	common service // Reuse a single struct instead of allocating one for each service on the heap.
 
@@ -172,7 +175,7 @@ type RawOptions struct {
 	Type RawType
 }
 
-// addOptions adds the parameters in opt as URL query parameters to s.  opt
+// addOptions adds the parameters in opt as URL query parameters to s. opt
 // must be a struct whose fields may contain "url" tags.
 func addOptions(s string, opt interface{}) (string, error) {
 	v := reflect.ValueOf(opt)
@@ -194,8 +197,8 @@ func addOptions(s string, opt interface{}) (string, error) {
 	return u.String(), nil
 }
 
-// NewClient returns a new GitHub API client.  If a nil httpClient is
-// provided, http.DefaultClient will be used.  To use API methods which require
+// NewClient returns a new GitHub API client. If a nil httpClient is
+// provided, http.DefaultClient will be used. To use API methods which require
 // authentication, provide an http.Client that will perform the authentication
 // for you (such as that provided by the golang.org/x/oauth2 library).
 func NewClient(httpClient *http.Client) *Client {
@@ -229,7 +232,7 @@ func NewClient(httpClient *http.Client) *Client {
 
 // NewRequest creates an API request. A relative URL can be provided in urlStr,
 // in which case it is resolved relative to the BaseURL of the Client.
-// Relative URLs should always be specified without a preceding slash.  If
+// Relative URLs should always be specified without a preceding slash. If
 // specified, the value pointed to by body is JSON encoded and included as the
 // request body.
 func (c *Client) NewRequest(method, urlStr string, body interface{}) (*http.Request, error) {
@@ -289,14 +292,14 @@ func (c *Client) NewUploadRequest(urlStr string, reader io.Reader, size int64, m
 	return req, nil
 }
 
-// Response is a GitHub API response.  This wraps the standard http.Response
+// Response is a GitHub API response. This wraps the standard http.Response
 // returned from GitHub and provides convenient access to things like
 // pagination links.
 type Response struct {
 	*http.Response
 
 	// These fields provide the page values for paginating through a set of
-	// results.  Any or all of these may be set to the zero value for
+	// results. Any or all of these may be set to the zero value for
 	// responses that are not part of a paginated set, or for which there
 	// are no additional pages.
 
@@ -377,26 +380,18 @@ func parseRate(r *http.Response) Rate {
 	return rate
 }
 
-// Rate specifies the current rate limit for the client as determined by the
-// most recent API call.  If the client is used in a multi-user application,
-// this rate may not always be up-to-date.
-//
-// Deprecated: Use the Response.Rate returned from most recent API call instead.
-// Call RateLimits() to check the current rate.
-func (c *Client) Rate() Rate {
-	c.rateMu.Lock()
-	rate := c.rateLimits[c.mostRecent]
-	c.rateMu.Unlock()
-	return rate
-}
-
-// Do sends an API request and returns the API response.  The API response is
+// Do sends an API request and returns the API response. The API response is
 // JSON decoded and stored in the value pointed to by v, or returned as an
-// error if an API error has occurred.  If v implements the io.Writer
+// error if an API error has occurred. If v implements the io.Writer
 // interface, the raw response body will be written to v, without attempting to
-// first decode it.  If rate limit is exceeded and reset time is in the future,
+// first decode it. If rate limit is exceeded and reset time is in the future,
 // Do returns *RateLimitError immediately without making a network API call.
-func (c *Client) Do(req *http.Request, v interface{}) (*Response, error) {
+//
+// The provided ctx must be non-nil. If it is canceled or times out,
+// ctx.Err() will be returned.
+func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) (*Response, error) {
+	ctx, req = withContext(ctx, req)
+
 	rateLimitCategory := category(req.URL.Path)
 
 	// If we've hit rate limit, don't make further requests before Reset time.
@@ -406,6 +401,22 @@ func (c *Client) Do(req *http.Request, v interface{}) (*Response, error) {
 
 	resp, err := c.client.Do(req)
 	if err != nil {
+		// If we got an error, and the context has been canceled,
+		// the context's error is probably more useful.
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+
+		// If the error type is *url.Error, sanitize its URL before returning.
+		if e, ok := err.(*url.Error); ok {
+			if url, err := url.Parse(e.URL); err == nil {
+				e.URL = sanitizeURL(url).String()
+				return nil, e
+			}
+		}
+
 		return nil, err
 	}
 
@@ -419,7 +430,6 @@ func (c *Client) Do(req *http.Request, v interface{}) (*Response, error) {
 
 	c.rateMu.Lock()
 	c.rateLimits[rateLimitCategory] = response.Rate
-	c.mostRecent = rateLimitCategory
 	c.rateMu.Unlock()
 
 	err = CheckResponse(resp)
@@ -473,7 +483,7 @@ func (c *Client) checkRateLimitBeforeDo(req *http.Request, rateLimitCategory rat
 /*
 An ErrorResponse reports one or more errors caused by an API request.
 
-GitHub API docs: http://developer.github.com/v3/#client-errors
+GitHub API docs: https://developer.github.com/v3/#client-errors
 */
 type ErrorResponse struct {
 	Response *http.Response // HTTP response that caused this error
@@ -499,7 +509,7 @@ func (r *ErrorResponse) Error() string {
 }
 
 // TwoFactorAuthError occurs when using HTTP Basic Authentication for a user
-// that has two-factor authentication enabled.  The request can be reattempted
+// that has two-factor authentication enabled. The request can be reattempted
 // by providing a one-time password in the request.
 type TwoFactorAuthError ErrorResponse
 
@@ -550,7 +560,7 @@ func (r *AbuseRateLimitError) Error() string {
 }
 
 // sanitizeURL redacts the client_secret parameter from the URL which may be
-// exposed to the user, specifically in the ErrorResponse error message.
+// exposed to the user.
 func sanitizeURL(uri *url.URL) *url.URL {
 	if uri == nil {
 		return nil
@@ -579,7 +589,7 @@ These are the possible validation error codes:
         some resources return this (e.g. github.User.CreateKey()), additional
         information is set in the Message field of the Error
 
-GitHub API docs: http://developer.github.com/v3/#client-errors
+GitHub API docs: https://developer.github.com/v3/#client-errors
 */
 type Error struct {
 	Resource string `json:"resource"` // resource on which the error occurred
@@ -597,7 +607,7 @@ func (e *Error) Error() string {
 // present. A response is considered an error if it has a status code outside
 // the 200 range or equal to 202 Accepted.
 // API error responses are expected to have either no response
-// body, or a JSON response body that maps to ErrorResponse.  Any other
+// body, or a JSON response body that maps to ErrorResponse. Any other
 // response body will be silently ignored.
 //
 // The error type will be *RateLimitError for rate limit exceeded errors,
@@ -646,15 +656,15 @@ func CheckResponse(r *http.Response) error {
 // parseBoolResponse determines the boolean result from a GitHub API response.
 // Several GitHub API methods return boolean responses indicated by the HTTP
 // status code in the response (true indicated by a 204, false indicated by a
-// 404).  This helper function will determine that result and hide the 404
-// error if present.  Any other error will be returned through as-is.
+// 404). This helper function will determine that result and hide the 404
+// error if present. Any other error will be returned through as-is.
 func parseBoolResponse(err error) (bool, error) {
 	if err == nil {
 		return true, nil
 	}
 
 	if err, ok := err.(*ErrorResponse); ok && err.Response.StatusCode == http.StatusNotFound {
-		// Simply false.  In this one case, we do not pass the error through.
+		// Simply false. In this one case, we do not pass the error through.
 		return false, nil
 	}
 
@@ -680,15 +690,15 @@ func (r Rate) String() string {
 
 // RateLimits represents the rate limits for the current client.
 type RateLimits struct {
-	// The rate limit for non-search API requests.  Unauthenticated
-	// requests are limited to 60 per hour.  Authenticated requests are
+	// The rate limit for non-search API requests. Unauthenticated
+	// requests are limited to 60 per hour. Authenticated requests are
 	// limited to 5,000 per hour.
 	//
 	// GitHub API docs: https://developer.github.com/v3/#rate-limiting
 	Core *Rate `json:"core"`
 
-	// The rate limit for search API requests.  Unauthenticated requests
-	// are limited to 10 requests per minutes.  Authenticated requests are
+	// The rate limit for search API requests. Unauthenticated requests
+	// are limited to 10 requests per minutes. Authenticated requests are
 	// limited to 30 per minute.
 	//
 	// GitHub API docs: https://developer.github.com/v3/search/#rate-limit
@@ -718,20 +728,8 @@ func category(path string) rateLimitCategory {
 	}
 }
 
-// RateLimit returns the core rate limit for the current client.
-//
-// Deprecated: RateLimit is deprecated, use RateLimits instead.
-func (c *Client) RateLimit() (*Rate, *Response, error) {
-	limits, resp, err := c.RateLimits()
-	if limits == nil {
-		return nil, nil, err
-	}
-
-	return limits.Core, resp, err
-}
-
 // RateLimits returns the rate limits for the current client.
-func (c *Client) RateLimits() (*RateLimits, *Response, error) {
+func (c *Client) RateLimits(ctx context.Context) (*RateLimits, *Response, error) {
 	req, err := c.NewRequest("GET", "rate_limit", nil)
 	if err != nil {
 		return nil, nil, err
@@ -740,7 +738,7 @@ func (c *Client) RateLimits() (*RateLimits, *Response, error) {
 	response := new(struct {
 		Resources *RateLimits `json:"resources"`
 	})
-	resp, err := c.Do(req, response)
+	resp, err := c.Do(ctx, req, response)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -756,7 +754,7 @@ func (c *Client) RateLimits() (*RateLimits, *Response, error) {
 		c.rateMu.Unlock()
 	}
 
-	return response.Resources, resp, err
+	return response.Resources, resp, nil
 }
 
 /*
@@ -772,7 +770,7 @@ that need to use a higher rate limit associated with your OAuth application.
 This will append the querystring params client_id=xxx&client_secret=yyy to all
 requests.
 
-See http://developer.github.com/v3/#unauthenticated-rate-limited-requests for
+See https://developer.github.com/v3/#unauthenticated-rate-limited-requests for
 more information.
 */
 type UnauthenticatedRateLimitedTransport struct {
@@ -826,7 +824,7 @@ func (t *UnauthenticatedRateLimitedTransport) transport() http.RoundTripper {
 }
 
 // BasicAuthTransport is an http.RoundTripper that authenticates all requests
-// using HTTP Basic Authentication with the provided username and password.  It
+// using HTTP Basic Authentication with the provided username and password. It
 // additionally supports users who have two-factor authentication enabled on
 // their GitHub account.
 type BasicAuthTransport struct {

vendor/github.com/google/go-github/github/gitignore.go

@@ -5,12 +5,15 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // GitignoresService provides access to the gitignore related functions in the
 // GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/gitignore/
+// GitHub API docs: https://developer.github.com/v3/gitignore/
 type GitignoresService service
 
 // Gitignore represents a .gitignore file as returned by the GitHub API.
@@ -25,26 +28,26 @@ func (g Gitignore) String() string {
 
 // List all available Gitignore templates.
 //
-// http://developer.github.com/v3/gitignore/#listing-available-templates
-func (s GitignoresService) List() ([]string, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gitignore/#listing-available-templates
+func (s GitignoresService) List(ctx context.Context) ([]string, *Response, error) {
 	req, err := s.client.NewRequest("GET", "gitignore/templates", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	availableTemplates := new([]string)
-	resp, err := s.client.Do(req, availableTemplates)
+	var availableTemplates []string
+	resp, err := s.client.Do(ctx, req, &availableTemplates)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *availableTemplates, resp, err
+	return availableTemplates, resp, nil
 }
 
 // Get a Gitignore by name.
 //
-// http://developer.github.com/v3/gitignore/#get-a-single-template
-func (s GitignoresService) Get(name string) (*Gitignore, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/gitignore/#get-a-single-template
+func (s GitignoresService) Get(ctx context.Context, name string) (*Gitignore, *Response, error) {
 	u := fmt.Sprintf("gitignore/templates/%v", name)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -52,10 +55,10 @@ func (s GitignoresService) Get(name string) (*Gitignore, *Response, error) {
 	}
 
 	gitignore := new(Gitignore)
-	resp, err := s.client.Do(req, gitignore)
+	resp, err := s.client.Do(ctx, req, gitignore)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return gitignore, resp, err
+	return gitignore, resp, nil
 }

vendor/github.com/google/go-github/github/integration.go

@@ -5,6 +5,8 @@
 
 package github
 
+import "context"
+
 // IntegrationsService provides access to the installation related functions
 // in the GitHub API.
 //
@@ -14,7 +16,7 @@ type IntegrationsService service
 // ListInstallations lists the installations that the current integration has.
 //
 // GitHub API docs: https://developer.github.com/v3/integrations/#find-installations
-func (s *IntegrationsService) ListInstallations(opt *ListOptions) ([]*Installation, *Response, error) {
+func (s *IntegrationsService) ListInstallations(ctx context.Context, opt *ListOptions) ([]*Installation, *Response, error) {
 	u, err := addOptions("integration/installations", opt)
 	if err != nil {
 		return nil, nil, err
@@ -28,11 +30,11 @@ func (s *IntegrationsService) ListInstallations(opt *ListOptions) ([]*Installati
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeIntegrationPreview)
 
-	i := new([]*Installation)
-	resp, err := s.client.Do(req, &i)
+	var i []*Installation
+	resp, err := s.client.Do(ctx, req, &i)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *i, resp, err
+	return i, resp, nil
 }

vendor/github.com/google/go-github/github/integration_installation.go

@@ -5,12 +5,15 @@
 
 package github
 
+import "context"
+
 // Installation represents a GitHub integration installation.
 type Installation struct {
 	ID              *int    `json:"id,omitempty"`
 	Account         *User   `json:"account,omitempty"`
 	AccessTokensURL *string `json:"access_tokens_url,omitempty"`
 	RepositoriesURL *string `json:"repositories_url,omitempty"`
+	HTMLURL         *string `json:"html_url,omitempty"`
 }
 
 func (i Installation) String() string {
@@ -20,7 +23,7 @@ func (i Installation) String() string {
 // ListRepos lists the repositories that the current installation has access to.
 //
 // GitHub API docs: https://developer.github.com/v3/integrations/installations/#list-repositories
-func (s *IntegrationsService) ListRepos(opt *ListOptions) ([]*Repository, *Response, error) {
+func (s *IntegrationsService) ListRepos(ctx context.Context, opt *ListOptions) ([]*Repository, *Response, error) {
 	u, err := addOptions("installation/repositories", opt)
 	if err != nil {
 		return nil, nil, err
@@ -37,10 +40,10 @@ func (s *IntegrationsService) ListRepos(opt *ListOptions) ([]*Repository, *Respo
 	var r struct {
 		Repositories []*Repository `json:"repositories"`
 	}
-	resp, err := s.client.Do(req, &r)
+	resp, err := s.client.Do(ctx, req, &r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r.Repositories, resp, err
+	return r.Repositories, resp, nil
 }

vendor/github.com/google/go-github/github/issues.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -13,7 +14,7 @@ import (
 // IssuesService handles communication with the issue related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/
+// GitHub API docs: https://developer.github.com/v3/issues/
 type IssuesService service
 
 // Issue represents a GitHub issue on a repository.
@@ -26,6 +27,7 @@ type Issue struct {
 	ID               *int              `json:"id,omitempty"`
 	Number           *int              `json:"number,omitempty"`
 	State            *string           `json:"state,omitempty"`
+	Locked           *bool             `json:"locked,omitempty"`
 	Title            *string           `json:"title,omitempty"`
 	Body             *string           `json:"body,omitempty"`
 	User             *User             `json:"user,omitempty"`
@@ -35,6 +37,7 @@ type Issue struct {
 	ClosedAt         *time.Time        `json:"closed_at,omitempty"`
 	CreatedAt        *time.Time        `json:"created_at,omitempty"`
 	UpdatedAt        *time.Time        `json:"updated_at,omitempty"`
+	ClosedBy         *User             `json:"closed_by,omitempty"`
 	URL              *string           `json:"url,omitempty"`
 	HTMLURL          *string           `json:"html_url,omitempty"`
 	Milestone        *Milestone        `json:"milestone,omitempty"`
@@ -68,22 +71,22 @@ type IssueRequest struct {
 // IssueListOptions specifies the optional parameters to the IssuesService.List
 // and IssuesService.ListByOrg methods.
 type IssueListOptions struct {
-	// Filter specifies which issues to list.  Possible values are: assigned,
-	// created, mentioned, subscribed, all.  Default is "assigned".
+	// Filter specifies which issues to list. Possible values are: assigned,
+	// created, mentioned, subscribed, all. Default is "assigned".
 	Filter string `url:"filter,omitempty"`
 
-	// State filters issues based on their state.  Possible values are: open,
-	// closed, all.  Default is "open".
+	// State filters issues based on their state. Possible values are: open,
+	// closed, all. Default is "open".
 	State string `url:"state,omitempty"`
 
 	// Labels filters issues based on their label.
 	Labels []string `url:"labels,comma,omitempty"`
 
-	// Sort specifies how to sort issues.  Possible values are: created, updated,
-	// and comments.  Default value is "created".
+	// Sort specifies how to sort issues. Possible values are: created, updated,
+	// and comments. Default value is "created".
 	Sort string `url:"sort,omitempty"`
 
-	// Direction in which to sort issues.  Possible values are: asc, desc.
+	// Direction in which to sort issues. Possible values are: asc, desc.
 	// Default is "desc".
 	Direction string `url:"direction,omitempty"`
 
@@ -102,32 +105,32 @@ type PullRequestLinks struct {
 	PatchURL *string `json:"patch_url,omitempty"`
 }
 
-// List the issues for the authenticated user.  If all is true, list issues
+// List the issues for the authenticated user. If all is true, list issues
 // across all the user's visible repositories including owned, member, and
 // organization repositories; if false, list only owned and member
 // repositories.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/#list-issues
-func (s *IssuesService) List(all bool, opt *IssueListOptions) ([]*Issue, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/#list-issues
+func (s *IssuesService) List(ctx context.Context, all bool, opt *IssueListOptions) ([]*Issue, *Response, error) {
 	var u string
 	if all {
 		u = "issues"
 	} else {
 		u = "user/issues"
 	}
-	return s.listIssues(u, opt)
+	return s.listIssues(ctx, u, opt)
 }
 
 // ListByOrg fetches the issues in the specified organization for the
 // authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/#list-issues
-func (s *IssuesService) ListByOrg(org string, opt *IssueListOptions) ([]*Issue, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/#list-issues
+func (s *IssuesService) ListByOrg(ctx context.Context, org string, opt *IssueListOptions) ([]*Issue, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/issues", org)
-	return s.listIssues(u, opt)
+	return s.listIssues(ctx, u, opt)
 }
 
-func (s *IssuesService) listIssues(u string, opt *IssueListOptions) ([]*Issue, *Response, error) {
+func (s *IssuesService) listIssues(ctx context.Context, u string, opt *IssueListOptions) ([]*Issue, *Response, error) {
 	u, err := addOptions(u, opt)
 	if err != nil {
 		return nil, nil, err
@@ -141,28 +144,28 @@ func (s *IssuesService) listIssues(u string, opt *IssueListOptions) ([]*Issue, *
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	issues := new([]*Issue)
-	resp, err := s.client.Do(req, issues)
+	var issues []*Issue
+	resp, err := s.client.Do(ctx, req, &issues)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *issues, resp, err
+	return issues, resp, nil
 }
 
 // IssueListByRepoOptions specifies the optional parameters to the
 // IssuesService.ListByRepo method.
 type IssueListByRepoOptions struct {
-	// Milestone limits issues for the specified milestone.  Possible values are
+	// Milestone limits issues for the specified milestone. Possible values are
 	// a milestone number, "none" for issues with no milestone, "*" for issues
 	// with any milestone.
 	Milestone string `url:"milestone,omitempty"`
 
-	// State filters issues based on their state.  Possible values are: open,
-	// closed, all.  Default is "open".
+	// State filters issues based on their state. Possible values are: open,
+	// closed, all. Default is "open".
 	State string `url:"state,omitempty"`
 
-	// Assignee filters issues based on their assignee.  Possible values are a
+	// Assignee filters issues based on their assignee. Possible values are a
 	// user name, "none" for issues that are not assigned, "*" for issues with
 	// any assigned user.
 	Assignee string `url:"assignee,omitempty"`
@@ -176,11 +179,11 @@ type IssueListByRepoOptions struct {
 	// Labels filters issues based on their label.
 	Labels []string `url:"labels,omitempty,comma"`
 
-	// Sort specifies how to sort issues.  Possible values are: created, updated,
-	// and comments.  Default value is "created".
+	// Sort specifies how to sort issues. Possible values are: created, updated,
+	// and comments. Default value is "created".
 	Sort string `url:"sort,omitempty"`
 
-	// Direction in which to sort issues.  Possible values are: asc, desc.
+	// Direction in which to sort issues. Possible values are: asc, desc.
 	// Default is "desc".
 	Direction string `url:"direction,omitempty"`
 
@@ -192,8 +195,8 @@ type IssueListByRepoOptions struct {
 
 // ListByRepo lists the issues for the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/#list-issues-for-a-repository
-func (s *IssuesService) ListByRepo(owner string, repo string, opt *IssueListByRepoOptions) ([]*Issue, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/#list-issues-for-a-repository
+func (s *IssuesService) ListByRepo(ctx context.Context, owner string, repo string, opt *IssueListByRepoOptions) ([]*Issue, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -208,19 +211,19 @@ func (s *IssuesService) ListByRepo(owner string, repo string, opt *IssueListByRe
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	issues := new([]*Issue)
-	resp, err := s.client.Do(req, issues)
+	var issues []*Issue
+	resp, err := s.client.Do(ctx, req, &issues)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *issues, resp, err
+	return issues, resp, nil
 }
 
 // Get a single issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/#get-a-single-issue
-func (s *IssuesService) Get(owner string, repo string, number int) (*Issue, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/#get-a-single-issue
+func (s *IssuesService) Get(ctx context.Context, owner string, repo string, number int) (*Issue, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d", owner, repo, number)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -231,18 +234,18 @@ func (s *IssuesService) Get(owner string, repo string, number int) (*Issue, *Res
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	issue := new(Issue)
-	resp, err := s.client.Do(req, issue)
+	resp, err := s.client.Do(ctx, req, issue)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return issue, resp, err
+	return issue, resp, nil
 }
 
 // Create a new issue on the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/#create-an-issue
-func (s *IssuesService) Create(owner string, repo string, issue *IssueRequest) (*Issue, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/#create-an-issue
+func (s *IssuesService) Create(ctx context.Context, owner string, repo string, issue *IssueRequest) (*Issue, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues", owner, repo)
 	req, err := s.client.NewRequest("POST", u, issue)
 	if err != nil {
@@ -250,18 +253,18 @@ func (s *IssuesService) Create(owner string, repo string, issue *IssueRequest) (
 	}
 
 	i := new(Issue)
-	resp, err := s.client.Do(req, i)
+	resp, err := s.client.Do(ctx, req, i)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return i, resp, err
+	return i, resp, nil
 }
 
 // Edit an issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/#edit-an-issue
-func (s *IssuesService) Edit(owner string, repo string, number int, issue *IssueRequest) (*Issue, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/#edit-an-issue
+func (s *IssuesService) Edit(ctx context.Context, owner string, repo string, number int, issue *IssueRequest) (*Issue, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d", owner, repo, number)
 	req, err := s.client.NewRequest("PATCH", u, issue)
 	if err != nil {
@@ -269,36 +272,36 @@ func (s *IssuesService) Edit(owner string, repo string, number int, issue *Issue
 	}
 
 	i := new(Issue)
-	resp, err := s.client.Do(req, i)
+	resp, err := s.client.Do(ctx, req, i)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return i, resp, err
+	return i, resp, nil
 }
 
 // Lock an issue's conversation.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/#lock-an-issue
-func (s *IssuesService) Lock(owner string, repo string, number int) (*Response, error) {
+func (s *IssuesService) Lock(ctx context.Context, owner string, repo string, number int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/lock", owner, repo, number)
 	req, err := s.client.NewRequest("PUT", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Unlock an issue's conversation.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/#unlock-an-issue
-func (s *IssuesService) Unlock(owner string, repo string, number int) (*Response, error) {
+func (s *IssuesService) Unlock(ctx context.Context, owner string, repo string, number int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/lock", owner, repo, number)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/issues_assignees.go

@@ -5,13 +5,16 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // ListAssignees fetches all available assignees (owners and collaborators) to
 // which issues may be assigned.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/assignees/#list-assignees
-func (s *IssuesService) ListAssignees(owner, repo string, opt *ListOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/assignees/#list-assignees
+func (s *IssuesService) ListAssignees(ctx context.Context, owner, repo string, opt *ListOptions) ([]*User, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/assignees", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -22,25 +25,25 @@ func (s *IssuesService) ListAssignees(owner, repo string, opt *ListOptions) ([]*
 	if err != nil {
 		return nil, nil, err
 	}
-	assignees := new([]*User)
-	resp, err := s.client.Do(req, assignees)
+	var assignees []*User
+	resp, err := s.client.Do(ctx, req, &assignees)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *assignees, resp, err
+	return assignees, resp, nil
 }
 
 // IsAssignee checks if a user is an assignee for the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/assignees/#check-assignee
-func (s *IssuesService) IsAssignee(owner, repo, user string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/assignees/#check-assignee
+func (s *IssuesService) IsAssignee(ctx context.Context, owner, repo, user string) (bool, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/assignees/%v", owner, repo, user)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	assignee, err := parseBoolResponse(err)
 	return assignee, resp, err
 }
@@ -48,7 +51,7 @@ func (s *IssuesService) IsAssignee(owner, repo, user string) (bool, *Response, e
 // AddAssignees adds the provided GitHub users as assignees to the issue.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/assignees/#add-assignees-to-an-issue
-func (s *IssuesService) AddAssignees(owner, repo string, number int, assignees []string) (*Issue, *Response, error) {
+func (s *IssuesService) AddAssignees(ctx context.Context, owner, repo string, number int, assignees []string) (*Issue, *Response, error) {
 	users := &struct {
 		Assignees []string `json:"assignees,omitempty"`
 	}{Assignees: assignees}
@@ -59,14 +62,14 @@ func (s *IssuesService) AddAssignees(owner, repo string, number int, assignees [
 	}
 
 	issue := &Issue{}
-	resp, err := s.client.Do(req, issue)
+	resp, err := s.client.Do(ctx, req, issue)
 	return issue, resp, err
 }
 
 // RemoveAssignees removes the provided GitHub users as assignees from the issue.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/assignees/#remove-assignees-from-an-issue
-func (s *IssuesService) RemoveAssignees(owner, repo string, number int, assignees []string) (*Issue, *Response, error) {
+func (s *IssuesService) RemoveAssignees(ctx context.Context, owner, repo string, number int, assignees []string) (*Issue, *Response, error) {
 	users := &struct {
 		Assignees []string `json:"assignees,omitempty"`
 	}{Assignees: assignees}
@@ -77,6 +80,6 @@ func (s *IssuesService) RemoveAssignees(owner, repo string, number int, assignee
 	}
 
 	issue := &Issue{}
-	resp, err := s.client.Do(req, issue)
+	resp, err := s.client.Do(ctx, req, issue)
 	return issue, resp, err
 }

vendor/github.com/google/go-github/github/issues_comments.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -30,10 +31,10 @@ func (i IssueComment) String() string {
 // IssueListCommentsOptions specifies the optional parameters to the
 // IssuesService.ListComments method.
 type IssueListCommentsOptions struct {
-	// Sort specifies how to sort comments.  Possible values are: created, updated.
+	// Sort specifies how to sort comments. Possible values are: created, updated.
 	Sort string `url:"sort,omitempty"`
 
-	// Direction in which to sort comments.  Possible values are: asc, desc.
+	// Direction in which to sort comments. Possible values are: asc, desc.
 	Direction string `url:"direction,omitempty"`
 
 	// Since filters comments by time.
@@ -42,11 +43,11 @@ type IssueListCommentsOptions struct {
 	ListOptions
 }
 
-// ListComments lists all comments on the specified issue.  Specifying an issue
+// ListComments lists all comments on the specified issue. Specifying an issue
 // number of 0 will return all comments on all issues for the repository.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
-func (s *IssuesService) ListComments(owner string, repo string, number int, opt *IssueListCommentsOptions) ([]*IssueComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
+func (s *IssuesService) ListComments(ctx context.Context, owner string, repo string, number int, opt *IssueListCommentsOptions) ([]*IssueComment, *Response, error) {
 	var u string
 	if number == 0 {
 		u = fmt.Sprintf("repos/%v/%v/issues/comments", owner, repo)
@@ -66,19 +67,19 @@ func (s *IssuesService) ListComments(owner string, repo string, number int, opt
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	comments := new([]*IssueComment)
-	resp, err := s.client.Do(req, comments)
+	var comments []*IssueComment
+	resp, err := s.client.Do(ctx, req, &comments)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *comments, resp, err
+	return comments, resp, nil
 }
 
 // GetComment fetches the specified issue comment.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/comments/#get-a-single-comment
-func (s *IssuesService) GetComment(owner string, repo string, id int) (*IssueComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/comments/#get-a-single-comment
+func (s *IssuesService) GetComment(ctx context.Context, owner string, repo string, id int) (*IssueComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/comments/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -90,58 +91,58 @@ func (s *IssuesService) GetComment(owner string, repo string, id int) (*IssueCom
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	comment := new(IssueComment)
-	resp, err := s.client.Do(req, comment)
+	resp, err := s.client.Do(ctx, req, comment)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return comment, resp, err
+	return comment, resp, nil
 }
 
 // CreateComment creates a new comment on the specified issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/comments/#create-a-comment
-func (s *IssuesService) CreateComment(owner string, repo string, number int, comment *IssueComment) (*IssueComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/comments/#create-a-comment
+func (s *IssuesService) CreateComment(ctx context.Context, owner string, repo string, number int, comment *IssueComment) (*IssueComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/comments", owner, repo, number)
 	req, err := s.client.NewRequest("POST", u, comment)
 	if err != nil {
 		return nil, nil, err
 	}
 	c := new(IssueComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // EditComment updates an issue comment.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/comments/#edit-a-comment
-func (s *IssuesService) EditComment(owner string, repo string, id int, comment *IssueComment) (*IssueComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/comments/#edit-a-comment
+func (s *IssuesService) EditComment(ctx context.Context, owner string, repo string, id int, comment *IssueComment) (*IssueComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/comments/%d", owner, repo, id)
 	req, err := s.client.NewRequest("PATCH", u, comment)
 	if err != nil {
 		return nil, nil, err
 	}
 	c := new(IssueComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // DeleteComment deletes an issue comment.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/comments/#delete-a-comment
-func (s *IssuesService) DeleteComment(owner string, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/comments/#delete-a-comment
+func (s *IssuesService) DeleteComment(ctx context.Context, owner string, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/comments/%d", owner, repo, id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/issues_events.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -18,7 +19,7 @@ type IssueEvent struct {
 	// The User that generated this event.
 	Actor *User `json:"actor,omitempty"`
 
-	// Event identifies the actual type of Event that occurred.  Possible
+	// Event identifies the actual type of Event that occurred. Possible
 	// values are:
 	//
 	//     closed
@@ -64,6 +65,7 @@ type IssueEvent struct {
 
 	// Only present on certain events; see above.
 	Assignee  *User      `json:"assignee,omitempty"`
+	Assigner  *User      `json:"assigner,omitempty"`
 	CommitID  *string    `json:"commit_id,omitempty"`
 	Milestone *Milestone `json:"milestone,omitempty"`
 	Label     *Label     `json:"label,omitempty"`
@@ -73,7 +75,7 @@ type IssueEvent struct {
 // ListIssueEvents lists events for the specified issue.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/events/#list-events-for-an-issue
-func (s *IssuesService) ListIssueEvents(owner, repo string, number int, opt *ListOptions) ([]*IssueEvent, *Response, error) {
+func (s *IssuesService) ListIssueEvents(ctx context.Context, owner, repo string, number int, opt *ListOptions) ([]*IssueEvent, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%v/events", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -86,18 +88,18 @@ func (s *IssuesService) ListIssueEvents(owner, repo string, number int, opt *Lis
 	}
 
 	var events []*IssueEvent
-	resp, err := s.client.Do(req, &events)
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return events, resp, err
+	return events, resp, nil
 }
 
 // ListRepositoryEvents lists events for the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/events/#list-events-for-a-repository
-func (s *IssuesService) ListRepositoryEvents(owner, repo string, opt *ListOptions) ([]*IssueEvent, *Response, error) {
+func (s *IssuesService) ListRepositoryEvents(ctx context.Context, owner, repo string, opt *ListOptions) ([]*IssueEvent, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/events", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -110,18 +112,18 @@ func (s *IssuesService) ListRepositoryEvents(owner, repo string, opt *ListOption
 	}
 
 	var events []*IssueEvent
-	resp, err := s.client.Do(req, &events)
+	resp, err := s.client.Do(ctx, req, &events)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return events, resp, err
+	return events, resp, nil
 }
 
 // GetEvent returns the specified issue event.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/events/#get-a-single-event
-func (s *IssuesService) GetEvent(owner, repo string, id int) (*IssueEvent, *Response, error) {
+func (s *IssuesService) GetEvent(ctx context.Context, owner, repo string, id int) (*IssueEvent, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/events/%v", owner, repo, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -130,12 +132,12 @@ func (s *IssuesService) GetEvent(owner, repo string, id int) (*IssueEvent, *Resp
 	}
 
 	event := new(IssueEvent)
-	resp, err := s.client.Do(req, event)
+	resp, err := s.client.Do(ctx, req, event)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return event, resp, err
+	return event, resp, nil
 }
 
 // Rename contains details for 'renamed' events.

vendor/github.com/google/go-github/github/issues_labels.go

@@ -5,10 +5,14 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Label represents a GitHub label on an Issue
 type Label struct {
+	ID    *int    `json:"id,omitempty"`
 	URL   *string `json:"url,omitempty"`
 	Name  *string `json:"name,omitempty"`
 	Color *string `json:"color,omitempty"`
@@ -20,8 +24,8 @@ func (l Label) String() string {
 
 // ListLabels lists all labels for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository
-func (s *IssuesService) ListLabels(owner string, repo string, opt *ListOptions) ([]*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository
+func (s *IssuesService) ListLabels(ctx context.Context, owner string, repo string, opt *ListOptions) ([]*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/labels", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -33,19 +37,19 @@ func (s *IssuesService) ListLabels(owner string, repo string, opt *ListOptions)
 		return nil, nil, err
 	}
 
-	labels := new([]*Label)
-	resp, err := s.client.Do(req, labels)
+	var labels []*Label
+	resp, err := s.client.Do(ctx, req, &labels)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *labels, resp, err
+	return labels, resp, nil
 }
 
 // GetLabel gets a single label.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#get-a-single-label
-func (s *IssuesService) GetLabel(owner string, repo string, name string) (*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#get-a-single-label
+func (s *IssuesService) GetLabel(ctx context.Context, owner string, repo string, name string) (*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/labels/%v", owner, repo, name)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -53,18 +57,18 @@ func (s *IssuesService) GetLabel(owner string, repo string, name string) (*Label
 	}
 
 	label := new(Label)
-	resp, err := s.client.Do(req, label)
+	resp, err := s.client.Do(ctx, req, label)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return label, resp, err
+	return label, resp, nil
 }
 
 // CreateLabel creates a new label on the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#create-a-label
-func (s *IssuesService) CreateLabel(owner string, repo string, label *Label) (*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#create-a-label
+func (s *IssuesService) CreateLabel(ctx context.Context, owner string, repo string, label *Label) (*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/labels", owner, repo)
 	req, err := s.client.NewRequest("POST", u, label)
 	if err != nil {
@@ -72,18 +76,18 @@ func (s *IssuesService) CreateLabel(owner string, repo string, label *Label) (*L
 	}
 
 	l := new(Label)
-	resp, err := s.client.Do(req, l)
+	resp, err := s.client.Do(ctx, req, l)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return l, resp, err
+	return l, resp, nil
 }
 
 // EditLabel edits a label.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#update-a-label
-func (s *IssuesService) EditLabel(owner string, repo string, name string, label *Label) (*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#update-a-label
+func (s *IssuesService) EditLabel(ctx context.Context, owner string, repo string, name string, label *Label) (*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/labels/%v", owner, repo, name)
 	req, err := s.client.NewRequest("PATCH", u, label)
 	if err != nil {
@@ -91,30 +95,30 @@ func (s *IssuesService) EditLabel(owner string, repo string, name string, label
 	}
 
 	l := new(Label)
-	resp, err := s.client.Do(req, l)
+	resp, err := s.client.Do(ctx, req, l)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return l, resp, err
+	return l, resp, nil
 }
 
 // DeleteLabel deletes a label.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#delete-a-label
-func (s *IssuesService) DeleteLabel(owner string, repo string, name string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#delete-a-label
+func (s *IssuesService) DeleteLabel(ctx context.Context, owner string, repo string, name string) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/labels/%v", owner, repo, name)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ListLabelsByIssue lists all labels for an issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository
-func (s *IssuesService) ListLabelsByIssue(owner string, repo string, number int, opt *ListOptions) ([]*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#list-labels-on-an-issue
+func (s *IssuesService) ListLabelsByIssue(ctx context.Context, owner string, repo string, number int, opt *ListOptions) ([]*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -126,81 +130,81 @@ func (s *IssuesService) ListLabelsByIssue(owner string, repo string, number int,
 		return nil, nil, err
 	}
 
-	labels := new([]*Label)
-	resp, err := s.client.Do(req, labels)
+	var labels []*Label
+	resp, err := s.client.Do(ctx, req, &labels)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *labels, resp, err
+	return labels, resp, nil
 }
 
 // AddLabelsToIssue adds labels to an issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository
-func (s *IssuesService) AddLabelsToIssue(owner string, repo string, number int, labels []string) ([]*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#add-labels-to-an-issue
+func (s *IssuesService) AddLabelsToIssue(ctx context.Context, owner string, repo string, number int, labels []string) ([]*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
 	req, err := s.client.NewRequest("POST", u, labels)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	l := new([]*Label)
-	resp, err := s.client.Do(req, l)
+	var l []*Label
+	resp, err := s.client.Do(ctx, req, &l)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *l, resp, err
+	return l, resp, nil
 }
 
 // RemoveLabelForIssue removes a label for an issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#remove-a-label-from-an-issue
-func (s *IssuesService) RemoveLabelForIssue(owner string, repo string, number int, label string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#remove-a-label-from-an-issue
+func (s *IssuesService) RemoveLabelForIssue(ctx context.Context, owner string, repo string, number int, label string) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels/%v", owner, repo, number, label)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ReplaceLabelsForIssue replaces all labels for an issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#replace-all-labels-for-an-issue
-func (s *IssuesService) ReplaceLabelsForIssue(owner string, repo string, number int, labels []string) ([]*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#replace-all-labels-for-an-issue
+func (s *IssuesService) ReplaceLabelsForIssue(ctx context.Context, owner string, repo string, number int, labels []string) ([]*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
 	req, err := s.client.NewRequest("PUT", u, labels)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	l := new([]*Label)
-	resp, err := s.client.Do(req, l)
+	var l []*Label
+	resp, err := s.client.Do(ctx, req, &l)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *l, resp, err
+	return l, resp, nil
 }
 
 // RemoveLabelsForIssue removes all labels for an issue.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#remove-all-labels-from-an-issue
-func (s *IssuesService) RemoveLabelsForIssue(owner string, repo string, number int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#remove-all-labels-from-an-issue
+func (s *IssuesService) RemoveLabelsForIssue(ctx context.Context, owner string, repo string, number int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ListLabelsForMilestone lists labels for every issue in a milestone.
 //
-// GitHub API docs: http://developer.github.com/v3/issues/labels/#get-labels-for-every-issue-in-a-milestone
-func (s *IssuesService) ListLabelsForMilestone(owner string, repo string, number int, opt *ListOptions) ([]*Label, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/issues/labels/#get-labels-for-every-issue-in-a-milestone
+func (s *IssuesService) ListLabelsForMilestone(ctx context.Context, owner string, repo string, number int, opt *ListOptions) ([]*Label, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/milestones/%d/labels", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -212,11 +216,11 @@ func (s *IssuesService) ListLabelsForMilestone(owner string, repo string, number
 		return nil, nil, err
 	}
 
-	labels := new([]*Label)
-	resp, err := s.client.Do(req, labels)
+	var labels []*Label
+	resp, err := s.client.Do(ctx, req, &labels)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *labels, resp, err
+	return labels, resp, nil
 }

vendor/github.com/google/go-github/github/issues_milestones.go

@@ -6,11 +6,12 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
 
-// Milestone represents a Github repository milestone.
+// Milestone represents a GitHub repository milestone.
 type Milestone struct {
 	URL          *string    `json:"url,omitempty"`
 	HTMLURL      *string    `json:"html_url,omitempty"`
@@ -37,11 +38,11 @@ func (m Milestone) String() string {
 // IssuesService.ListMilestones method.
 type MilestoneListOptions struct {
 	// State filters milestones based on their state. Possible values are:
-	// open, closed. Default is "open".
+	// open, closed, all. Default is "open".
 	State string `url:"state,omitempty"`
 
-	// Sort specifies how to sort milestones. Possible values are: due_date, completeness.
-	// Default value is "due_date".
+	// Sort specifies how to sort milestones. Possible values are: due_on, completeness.
+	// Default value is "due_on".
 	Sort string `url:"sort,omitempty"`
 
 	// Direction in which to sort milestones. Possible values are: asc, desc.
@@ -54,7 +55,7 @@ type MilestoneListOptions struct {
 // ListMilestones lists all milestones for a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository
-func (s *IssuesService) ListMilestones(owner string, repo string, opt *MilestoneListOptions) ([]*Milestone, *Response, error) {
+func (s *IssuesService) ListMilestones(ctx context.Context, owner string, repo string, opt *MilestoneListOptions) ([]*Milestone, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/milestones", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -66,19 +67,19 @@ func (s *IssuesService) ListMilestones(owner string, repo string, opt *Milestone
 		return nil, nil, err
 	}
 
-	milestones := new([]*Milestone)
-	resp, err := s.client.Do(req, milestones)
+	var milestones []*Milestone
+	resp, err := s.client.Do(ctx, req, &milestones)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *milestones, resp, err
+	return milestones, resp, nil
 }
 
 // GetMilestone gets a single milestone.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/milestones/#get-a-single-milestone
-func (s *IssuesService) GetMilestone(owner string, repo string, number int) (*Milestone, *Response, error) {
+func (s *IssuesService) GetMilestone(ctx context.Context, owner string, repo string, number int) (*Milestone, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/milestones/%d", owner, repo, number)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -86,18 +87,18 @@ func (s *IssuesService) GetMilestone(owner string, repo string, number int) (*Mi
 	}
 
 	milestone := new(Milestone)
-	resp, err := s.client.Do(req, milestone)
+	resp, err := s.client.Do(ctx, req, milestone)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return milestone, resp, err
+	return milestone, resp, nil
 }
 
 // CreateMilestone creates a new milestone on the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/milestones/#create-a-milestone
-func (s *IssuesService) CreateMilestone(owner string, repo string, milestone *Milestone) (*Milestone, *Response, error) {
+func (s *IssuesService) CreateMilestone(ctx context.Context, owner string, repo string, milestone *Milestone) (*Milestone, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/milestones", owner, repo)
 	req, err := s.client.NewRequest("POST", u, milestone)
 	if err != nil {
@@ -105,18 +106,18 @@ func (s *IssuesService) CreateMilestone(owner string, repo string, milestone *Mi
 	}
 
 	m := new(Milestone)
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return m, resp, err
+	return m, resp, nil
 }
 
 // EditMilestone edits a milestone.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/milestones/#update-a-milestone
-func (s *IssuesService) EditMilestone(owner string, repo string, number int, milestone *Milestone) (*Milestone, *Response, error) {
+func (s *IssuesService) EditMilestone(ctx context.Context, owner string, repo string, number int, milestone *Milestone) (*Milestone, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/milestones/%d", owner, repo, number)
 	req, err := s.client.NewRequest("PATCH", u, milestone)
 	if err != nil {
@@ -124,23 +125,23 @@ func (s *IssuesService) EditMilestone(owner string, repo string, number int, mil
 	}
 
 	m := new(Milestone)
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return m, resp, err
+	return m, resp, nil
 }
 
 // DeleteMilestone deletes a milestone.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/milestones/#delete-a-milestone
-func (s *IssuesService) DeleteMilestone(owner string, repo string, number int) (*Response, error) {
+func (s *IssuesService) DeleteMilestone(ctx context.Context, owner string, repo string, number int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/milestones/%d", owner, repo, number)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/issues_timeline.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -127,7 +128,7 @@ type Source struct {
 // ListIssueTimeline lists events for the specified issue.
 //
 // GitHub API docs: https://developer.github.com/v3/issues/timeline/#list-events-for-an-issue
-func (s *IssuesService) ListIssueTimeline(owner, repo string, number int, opt *ListOptions) ([]*Timeline, *Response, error) {
+func (s *IssuesService) ListIssueTimeline(ctx context.Context, owner, repo string, number int, opt *ListOptions) ([]*Timeline, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%v/timeline", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -143,6 +144,6 @@ func (s *IssuesService) ListIssueTimeline(owner, repo string, number int, opt *L
 	req.Header.Set("Accept", mediaTypeTimelinePreview)
 
 	var events []*Timeline
-	resp, err := s.client.Do(req, &events)
+	resp, err := s.client.Do(ctx, req, &events)
 	return events, resp, err
 }

vendor/github.com/google/go-github/github/licenses.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // LicensesService handles communication with the license related
 // methods of the GitHub API.
@@ -58,7 +61,7 @@ func (l License) String() string {
 // List popular open source licenses.
 //
 // GitHub API docs: https://developer.github.com/v3/licenses/#list-all-licenses
-func (s *LicensesService) List() ([]*License, *Response, error) {
+func (s *LicensesService) List(ctx context.Context) ([]*License, *Response, error) {
 	req, err := s.client.NewRequest("GET", "licenses", nil)
 	if err != nil {
 		return nil, nil, err
@@ -67,19 +70,19 @@ func (s *LicensesService) List() ([]*License, *Response, error) {
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeLicensesPreview)
 
-	licenses := new([]*License)
-	resp, err := s.client.Do(req, licenses)
+	var licenses []*License
+	resp, err := s.client.Do(ctx, req, &licenses)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *licenses, resp, err
+	return licenses, resp, nil
 }
 
 // Get extended metadata for one license.
 //
 // GitHub API docs: https://developer.github.com/v3/licenses/#get-an-individual-license
-func (s *LicensesService) Get(licenseName string) (*License, *Response, error) {
+func (s *LicensesService) Get(ctx context.Context, licenseName string) (*License, *Response, error) {
 	u := fmt.Sprintf("licenses/%s", licenseName)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -91,10 +94,10 @@ func (s *LicensesService) Get(licenseName string) (*License, *Response, error) {
 	req.Header.Set("Accept", mediaTypeLicensesPreview)
 
 	license := new(License)
-	resp, err := s.client.Do(req, license)
+	resp, err := s.client.Do(ctx, req, license)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return license, resp, err
+	return license, resp, nil
 }

vendor/github.com/google/go-github/github/messages.go

@@ -4,7 +4,7 @@
 // license that can be found in the LICENSE file.
 
 // This file provides functions for validating payloads from GitHub Webhooks.
-// GitHub docs: https://developer.github.com/webhooks/securing/#validating-payloads-from-github
+// GitHub API docs: https://developer.github.com/webhooks/securing/#validating-payloads-from-github
 
 package github
 
@@ -31,7 +31,7 @@ const (
 	sha512Prefix = "sha512"
 	// signatureHeader is the GitHub header key used to pass the HMAC hexdigest.
 	signatureHeader = "X-Hub-Signature"
-	// eventTypeHeader is the Github header key used to pass the event type.
+	// eventTypeHeader is the GitHub header key used to pass the event type.
 	eventTypeHeader = "X-Github-Event"
 )
 
@@ -53,8 +53,12 @@ var (
 		"member":                                "MemberEvent",
 		"membership":                            "MembershipEvent",
 		"milestone":                             "MilestoneEvent",
+		"organization":                          "OrganizationEvent",
 		"page_build":                            "PageBuildEvent",
 		"ping":                                  "PingEvent",
+		"project":                               "ProjectEvent",
+		"project_card":                          "ProjectCardEvent",
+		"project_column":                        "ProjectColumnEvent",
 		"public":                                "PublicEvent",
 		"pull_request_review":                   "PullRequestReviewEvent",
 		"pull_request_review_comment":           "PullRequestReviewCommentEvent",
@@ -142,7 +146,7 @@ func ValidatePayload(r *http.Request, secretKey []byte) (payload []byte, err err
 // payload is the JSON payload sent by GitHub Webhooks.
 // secretKey is the GitHub Webhook secret message.
 //
-// GitHub docs: https://developer.github.com/webhooks/securing/#validating-payloads-from-github
+// GitHub API docs: https://developer.github.com/webhooks/securing/#validating-payloads-from-github
 func validateSignature(signature string, payload, secretKey []byte) error {
 	messageMAC, hashFunc, err := messageMAC(signature)
 	if err != nil {
@@ -161,7 +165,7 @@ func WebHookType(r *http.Request) string {
 
 // ParseWebHook parses the event payload. For recognized event types, a
 // value of the corresponding struct type will be returned (as returned
-// by Event.Payload()). An error will be returned for unrecognized event
+// by Event.ParsePayload()). An error will be returned for unrecognized event
 // types.
 //
 // Example usage:
@@ -190,5 +194,5 @@ func ParseWebHook(messageType string, payload []byte) (interface{}, error) {
 		Type:       &eventType,
 		RawPayload: (*json.RawMessage)(&payload),
 	}
-	return event.Payload(), nil
+	return event.ParsePayload()
 }

vendor/github.com/google/go-github/github/migrations.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"net/http"
@@ -74,7 +75,7 @@ type startMigration struct {
 // repos is a slice of repository names to migrate.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/migrations/#start-a-migration
-func (s *MigrationService) StartMigration(org string, repos []string, opt *MigrationOptions) (*Migration, *Response, error) {
+func (s *MigrationService) StartMigration(ctx context.Context, org string, repos []string, opt *MigrationOptions) (*Migration, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/migrations", org)
 
 	body := &startMigration{Repositories: repos}
@@ -92,7 +93,7 @@ func (s *MigrationService) StartMigration(org string, repos []string, opt *Migra
 	req.Header.Set("Accept", mediaTypeMigrationsPreview)
 
 	m := &Migration{}
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -103,7 +104,7 @@ func (s *MigrationService) StartMigration(org string, repos []string, opt *Migra
 // ListMigrations lists the most recent migrations.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/migrations/#get-a-list-of-migrations
-func (s *MigrationService) ListMigrations(org string) ([]*Migration, *Response, error) {
+func (s *MigrationService) ListMigrations(ctx context.Context, org string) ([]*Migration, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/migrations", org)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -115,7 +116,7 @@ func (s *MigrationService) ListMigrations(org string) ([]*Migration, *Response,
 	req.Header.Set("Accept", mediaTypeMigrationsPreview)
 
 	var m []*Migration
-	resp, err := s.client.Do(req, &m)
+	resp, err := s.client.Do(ctx, req, &m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -127,7 +128,7 @@ func (s *MigrationService) ListMigrations(org string) ([]*Migration, *Response,
 // id is the migration ID.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/migrations/#get-the-status-of-a-migration
-func (s *MigrationService) MigrationStatus(org string, id int) (*Migration, *Response, error) {
+func (s *MigrationService) MigrationStatus(ctx context.Context, org string, id int) (*Migration, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/migrations/%v", org, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -139,7 +140,7 @@ func (s *MigrationService) MigrationStatus(org string, id int) (*Migration, *Res
 	req.Header.Set("Accept", mediaTypeMigrationsPreview)
 
 	m := &Migration{}
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -151,7 +152,7 @@ func (s *MigrationService) MigrationStatus(org string, id int) (*Migration, *Res
 // id is the migration ID.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/migrations/#download-a-migration-archive
-func (s *MigrationService) MigrationArchiveURL(org string, id int) (url string, err error) {
+func (s *MigrationService) MigrationArchiveURL(ctx context.Context, org string, id int) (url string, err error) {
 	u := fmt.Sprintf("orgs/%v/migrations/%v/archive", org, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -174,7 +175,7 @@ func (s *MigrationService) MigrationArchiveURL(org string, id int) (url string,
 	}
 	defer func() { s.client.client.CheckRedirect = saveRedirect }()
 
-	_, err = s.client.Do(req, nil) // expect error from disable redirect
+	_, err = s.client.Do(ctx, req, nil) // expect error from disable redirect
 	if err == nil {
 		return "", errors.New("expected redirect, none provided")
 	}
@@ -188,7 +189,7 @@ func (s *MigrationService) MigrationArchiveURL(org string, id int) (url string,
 // id is the migration ID.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/migrations/#delete-a-migration-archive
-func (s *MigrationService) DeleteMigration(org string, id int) (*Response, error) {
+func (s *MigrationService) DeleteMigration(ctx context.Context, org string, id int) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/migrations/%v/archive", org, id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -199,7 +200,7 @@ func (s *MigrationService) DeleteMigration(org string, id int) (*Response, error
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeMigrationsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // UnlockRepo unlocks a repository that was locked for migration.
@@ -208,7 +209,7 @@ func (s *MigrationService) DeleteMigration(org string, id int) (*Response, error
 // is complete and you no longer need the source data.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/migrations/#unlock-a-repository
-func (s *MigrationService) UnlockRepo(org string, id int, repo string) (*Response, error) {
+func (s *MigrationService) UnlockRepo(ctx context.Context, org string, id int, repo string) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/migrations/%v/repos/%v/lock", org, id, repo)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -219,5 +220,5 @@ func (s *MigrationService) UnlockRepo(org string, id int, repo string) (*Respons
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeMigrationsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/migrations_source_import.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Import represents a repository import request.
 type Import struct {
@@ -39,7 +42,7 @@ type Import struct {
 	// repository. To see a list of these files, call LargeFiles.
 	LargeFilesCount *int `json:"large_files_count,omitempty"`
 
-	// Identifies the current status of an import.  An import that does not
+	// Identifies the current status of an import. An import that does not
 	// have errors will progress through these steps:
 	//
 	//     detecting - the "detection" step of the import is in progress
@@ -101,7 +104,7 @@ type Import struct {
 	HumanName *string `json:"human_name,omitempty"`
 
 	// When the importer finds several projects or repositories at the
-	// provided URLs, this will identify the available choices.  Call
+	// provided URLs, this will identify the available choices. Call
 	// UpdateImport with the selected Import value.
 	ProjectChoices []Import `json:"project_choices,omitempty"`
 }
@@ -144,7 +147,7 @@ func (f LargeFile) String() string {
 // StartImport initiates a repository import.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#start-an-import
-func (s *MigrationService) StartImport(owner, repo string, in *Import) (*Import, *Response, error) {
+func (s *MigrationService) StartImport(ctx context.Context, owner, repo string, in *Import) (*Import, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
 	req, err := s.client.NewRequest("PUT", u, in)
 	if err != nil {
@@ -155,18 +158,18 @@ func (s *MigrationService) StartImport(owner, repo string, in *Import) (*Import,
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
 	out := new(Import)
-	resp, err := s.client.Do(req, out)
+	resp, err := s.client.Do(ctx, req, out)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return out, resp, err
+	return out, resp, nil
 }
 
 // ImportProgress queries for the status and progress of an ongoing repository import.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#get-import-progress
-func (s *MigrationService) ImportProgress(owner, repo string) (*Import, *Response, error) {
+func (s *MigrationService) ImportProgress(ctx context.Context, owner, repo string) (*Import, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -177,18 +180,18 @@ func (s *MigrationService) ImportProgress(owner, repo string) (*Import, *Respons
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
 	out := new(Import)
-	resp, err := s.client.Do(req, out)
+	resp, err := s.client.Do(ctx, req, out)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return out, resp, err
+	return out, resp, nil
 }
 
 // UpdateImport initiates a repository import.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#update-existing-import
-func (s *MigrationService) UpdateImport(owner, repo string, in *Import) (*Import, *Response, error) {
+func (s *MigrationService) UpdateImport(ctx context.Context, owner, repo string, in *Import) (*Import, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
 	req, err := s.client.NewRequest("PATCH", u, in)
 	if err != nil {
@@ -199,12 +202,12 @@ func (s *MigrationService) UpdateImport(owner, repo string, in *Import) (*Import
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
 	out := new(Import)
-	resp, err := s.client.Do(req, out)
+	resp, err := s.client.Do(ctx, req, out)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return out, resp, err
+	return out, resp, nil
 }
 
 // CommitAuthors gets the authors mapped from the original repository.
@@ -220,7 +223,7 @@ func (s *MigrationService) UpdateImport(owner, repo string, in *Import) (*Import
 // information.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#get-commit-authors
-func (s *MigrationService) CommitAuthors(owner, repo string) ([]*SourceImportAuthor, *Response, error) {
+func (s *MigrationService) CommitAuthors(ctx context.Context, owner, repo string) ([]*SourceImportAuthor, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import/authors", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -230,13 +233,13 @@ func (s *MigrationService) CommitAuthors(owner, repo string) ([]*SourceImportAut
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
-	authors := new([]*SourceImportAuthor)
-	resp, err := s.client.Do(req, authors)
+	var authors []*SourceImportAuthor
+	resp, err := s.client.Do(ctx, req, &authors)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *authors, resp, err
+	return authors, resp, nil
 }
 
 // MapCommitAuthor updates an author's identity for the import. Your
@@ -244,7 +247,7 @@ func (s *MigrationService) CommitAuthors(owner, repo string) ([]*SourceImportAut
 // commits to the repository.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#map-a-commit-author
-func (s *MigrationService) MapCommitAuthor(owner, repo string, id int, author *SourceImportAuthor) (*SourceImportAuthor, *Response, error) {
+func (s *MigrationService) MapCommitAuthor(ctx context.Context, owner, repo string, id int, author *SourceImportAuthor) (*SourceImportAuthor, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import/authors/%v", owner, repo, id)
 	req, err := s.client.NewRequest("PATCH", u, author)
 	if err != nil {
@@ -255,20 +258,20 @@ func (s *MigrationService) MapCommitAuthor(owner, repo string, id int, author *S
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
 	out := new(SourceImportAuthor)
-	resp, err := s.client.Do(req, out)
+	resp, err := s.client.Do(ctx, req, out)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return out, resp, err
+	return out, resp, nil
 }
 
 // SetLFSPreference sets whether imported repositories should use Git LFS for
-// files larger than 100MB.  Only the UseLFS field on the provided Import is
+// files larger than 100MB. Only the UseLFS field on the provided Import is
 // used.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#set-git-lfs-preference
-func (s *MigrationService) SetLFSPreference(owner, repo string, in *Import) (*Import, *Response, error) {
+func (s *MigrationService) SetLFSPreference(ctx context.Context, owner, repo string, in *Import) (*Import, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import/lfs", owner, repo)
 	req, err := s.client.NewRequest("PATCH", u, in)
 	if err != nil {
@@ -279,18 +282,18 @@ func (s *MigrationService) SetLFSPreference(owner, repo string, in *Import) (*Im
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
 	out := new(Import)
-	resp, err := s.client.Do(req, out)
+	resp, err := s.client.Do(ctx, req, out)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return out, resp, err
+	return out, resp, nil
 }
 
 // LargeFiles lists files larger than 100MB found during the import.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#get-large-files
-func (s *MigrationService) LargeFiles(owner, repo string) ([]*LargeFile, *Response, error) {
+func (s *MigrationService) LargeFiles(ctx context.Context, owner, repo string) ([]*LargeFile, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import/large_files", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -300,19 +303,19 @@ func (s *MigrationService) LargeFiles(owner, repo string) ([]*LargeFile, *Respon
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
-	files := new([]*LargeFile)
-	resp, err := s.client.Do(req, files)
+	var files []*LargeFile
+	resp, err := s.client.Do(ctx, req, &files)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *files, resp, err
+	return files, resp, nil
 }
 
 // CancelImport stops an import for a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/migration/source_imports/#cancel-an-import
-func (s *MigrationService) CancelImport(owner, repo string) (*Response, error) {
+func (s *MigrationService) CancelImport(ctx context.Context, owner, repo string) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -322,5 +325,5 @@ func (s *MigrationService) CancelImport(owner, repo string) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeImportPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/misc.go

@@ -7,13 +7,14 @@ package github
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"net/url"
 )
 
 // MarkdownOptions specifies optional parameters to the Markdown method.
 type MarkdownOptions struct {
-	// Mode identifies the rendering mode.  Possible values are:
+	// Mode identifies the rendering mode. Possible values are:
 	//   markdown - render a document as plain Markdown, just like
 	//   README files are rendered.
 	//
@@ -25,7 +26,7 @@ type MarkdownOptions struct {
 	// Default is "markdown".
 	Mode string
 
-	// Context identifies the repository context.  Only taken into account
+	// Context identifies the repository context. Only taken into account
 	// when rendering as "gfm".
 	Context string
 }
@@ -39,7 +40,7 @@ type markdownRequest struct {
 // Markdown renders an arbitrary Markdown document.
 //
 // GitHub API docs: https://developer.github.com/v3/markdown/
-func (c *Client) Markdown(text string, opt *MarkdownOptions) (string, *Response, error) {
+func (c *Client) Markdown(ctx context.Context, text string, opt *MarkdownOptions) (string, *Response, error) {
 	request := &markdownRequest{Text: String(text)}
 	if opt != nil {
 		if opt.Mode != "" {
@@ -56,7 +57,7 @@ func (c *Client) Markdown(text string, opt *MarkdownOptions) (string, *Response,
 	}
 
 	buf := new(bytes.Buffer)
-	resp, err := c.Do(req, buf)
+	resp, err := c.Do(ctx, req, buf)
 	if err != nil {
 		return "", resp, err
 	}
@@ -67,14 +68,14 @@ func (c *Client) Markdown(text string, opt *MarkdownOptions) (string, *Response,
 // ListEmojis returns the emojis available to use on GitHub.
 //
 // GitHub API docs: https://developer.github.com/v3/emojis/
-func (c *Client) ListEmojis() (map[string]string, *Response, error) {
+func (c *Client) ListEmojis(ctx context.Context) (map[string]string, *Response, error) {
 	req, err := c.NewRequest("GET", "emojis", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	var emoji map[string]string
-	resp, err := c.Do(req, &emoji)
+	resp, err := c.Do(ctx, req, &emoji)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -109,14 +110,14 @@ type APIMeta struct {
 // endpoint provides information about that installation.
 //
 // GitHub API docs: https://developer.github.com/v3/meta/
-func (c *Client) APIMeta() (*APIMeta, *Response, error) {
+func (c *Client) APIMeta(ctx context.Context) (*APIMeta, *Response, error) {
 	req, err := c.NewRequest("GET", "meta", nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	meta := new(APIMeta)
-	resp, err := c.Do(req, meta)
+	resp, err := c.Do(ctx, req, meta)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -125,8 +126,8 @@ func (c *Client) APIMeta() (*APIMeta, *Response, error) {
 }
 
 // Octocat returns an ASCII art octocat with the specified message in a speech
-// bubble.  If message is empty, a random zen phrase is used.
-func (c *Client) Octocat(message string) (string, *Response, error) {
+// bubble. If message is empty, a random zen phrase is used.
+func (c *Client) Octocat(ctx context.Context, message string) (string, *Response, error) {
 	u := "octocat"
 	if message != "" {
 		u = fmt.Sprintf("%s?s=%s", u, url.QueryEscape(message))
@@ -138,7 +139,7 @@ func (c *Client) Octocat(message string) (string, *Response, error) {
 	}
 
 	buf := new(bytes.Buffer)
-	resp, err := c.Do(req, buf)
+	resp, err := c.Do(ctx, req, buf)
 	if err != nil {
 		return "", resp, err
 	}
@@ -149,14 +150,14 @@ func (c *Client) Octocat(message string) (string, *Response, error) {
 // Zen returns a random line from The Zen of GitHub.
 //
 // see also: http://warpspire.com/posts/taste/
-func (c *Client) Zen() (string, *Response, error) {
+func (c *Client) Zen(ctx context.Context) (string, *Response, error) {
 	req, err := c.NewRequest("GET", "zen", nil)
 	if err != nil {
 		return "", nil, err
 	}
 
 	buf := new(bytes.Buffer)
-	resp, err := c.Do(req, buf)
+	resp, err := c.Do(ctx, req, buf)
 	if err != nil {
 		return "", resp, err
 	}
@@ -180,18 +181,18 @@ func (s *ServiceHook) String() string {
 // ListServiceHooks lists all of the available service hooks.
 //
 // GitHub API docs: https://developer.github.com/webhooks/#services
-func (c *Client) ListServiceHooks() ([]*ServiceHook, *Response, error) {
+func (c *Client) ListServiceHooks(ctx context.Context) ([]*ServiceHook, *Response, error) {
 	u := "hooks"
 	req, err := c.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	hooks := new([]*ServiceHook)
-	resp, err := c.Do(req, hooks)
+	var hooks []*ServiceHook
+	resp, err := c.Do(ctx, req, &hooks)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *hooks, resp, err
+	return hooks, resp, nil
 }

vendor/github.com/google/go-github/github/orgs.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -13,7 +14,7 @@ import (
 // OrganizationsService provides access to the organization related functions
 // in the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/
+// GitHub API docs: https://developer.github.com/v3/orgs/
 type OrganizationsService service
 
 // Organization represents a GitHub organization account.
@@ -57,7 +58,7 @@ func (o Organization) String() string {
 	return Stringify(o)
 }
 
-// Plan represents the payment plan for an account.  See plans at https://github.com/plans.
+// Plan represents the payment plan for an account. See plans at https://github.com/plans.
 type Plan struct {
 	Name          *string `json:"name,omitempty"`
 	Space         *int    `json:"space,omitempty"`
@@ -85,7 +86,7 @@ type OrganizationsListOptions struct {
 // as the opts.Since parameter for the next call.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/#list-all-organizations
-func (s *OrganizationsService) ListAll(opt *OrganizationsListOptions) ([]*Organization, *Response, error) {
+func (s *OrganizationsService) ListAll(ctx context.Context, opt *OrganizationsListOptions) ([]*Organization, *Response, error) {
 	u, err := addOptions("organizations", opt)
 	if err != nil {
 		return nil, nil, err
@@ -97,18 +98,18 @@ func (s *OrganizationsService) ListAll(opt *OrganizationsListOptions) ([]*Organi
 	}
 
 	orgs := []*Organization{}
-	resp, err := s.client.Do(req, &orgs)
+	resp, err := s.client.Do(ctx, req, &orgs)
 	if err != nil {
 		return nil, resp, err
 	}
-	return orgs, resp, err
+	return orgs, resp, nil
 }
 
-// List the organizations for a user.  Passing the empty string will list
+// List the organizations for a user. Passing the empty string will list
 // organizations for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/#list-user-organizations
-func (s *OrganizationsService) List(user string, opt *ListOptions) ([]*Organization, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/#list-user-organizations
+func (s *OrganizationsService) List(ctx context.Context, user string, opt *ListOptions) ([]*Organization, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/orgs", user)
@@ -125,19 +126,19 @@ func (s *OrganizationsService) List(user string, opt *ListOptions) ([]*Organizat
 		return nil, nil, err
 	}
 
-	orgs := new([]*Organization)
-	resp, err := s.client.Do(req, orgs)
+	var orgs []*Organization
+	resp, err := s.client.Do(ctx, req, &orgs)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *orgs, resp, err
+	return orgs, resp, nil
 }
 
 // Get fetches an organization by name.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/#get-an-organization
-func (s *OrganizationsService) Get(org string) (*Organization, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/#get-an-organization
+func (s *OrganizationsService) Get(ctx context.Context, org string) (*Organization, *Response, error) {
 	u := fmt.Sprintf("orgs/%v", org)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -145,18 +146,18 @@ func (s *OrganizationsService) Get(org string) (*Organization, *Response, error)
 	}
 
 	organization := new(Organization)
-	resp, err := s.client.Do(req, organization)
+	resp, err := s.client.Do(ctx, req, organization)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return organization, resp, err
+	return organization, resp, nil
 }
 
 // Edit an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/#edit-an-organization
-func (s *OrganizationsService) Edit(name string, org *Organization) (*Organization, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/#edit-an-organization
+func (s *OrganizationsService) Edit(ctx context.Context, name string, org *Organization) (*Organization, *Response, error) {
 	u := fmt.Sprintf("orgs/%v", name)
 	req, err := s.client.NewRequest("PATCH", u, org)
 	if err != nil {
@@ -164,10 +165,10 @@ func (s *OrganizationsService) Edit(name string, org *Organization) (*Organizati
 	}
 
 	o := new(Organization)
-	resp, err := s.client.Do(req, o)
+	resp, err := s.client.Do(ctx, req, o)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return o, resp, err
+	return o, resp, nil
 }

vendor/github.com/google/go-github/github/orgs_hooks.go

@@ -5,12 +5,15 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // ListHooks lists all Hooks for the specified organization.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/hooks/#list-hooks
-func (s *OrganizationsService) ListHooks(org string, opt *ListOptions) ([]*Hook, *Response, error) {
+func (s *OrganizationsService) ListHooks(ctx context.Context, org string, opt *ListOptions) ([]*Hook, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/hooks", org)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -22,26 +25,26 @@ func (s *OrganizationsService) ListHooks(org string, opt *ListOptions) ([]*Hook,
 		return nil, nil, err
 	}
 
-	hooks := new([]*Hook)
-	resp, err := s.client.Do(req, hooks)
+	var hooks []*Hook
+	resp, err := s.client.Do(ctx, req, &hooks)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *hooks, resp, err
+	return hooks, resp, nil
 }
 
 // GetHook returns a single specified Hook.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/hooks/#get-single-hook
-func (s *OrganizationsService) GetHook(org string, id int) (*Hook, *Response, error) {
+func (s *OrganizationsService) GetHook(ctx context.Context, org string, id int) (*Hook, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/hooks/%d", org, id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 	hook := new(Hook)
-	resp, err := s.client.Do(req, hook)
+	resp, err := s.client.Do(ctx, req, hook)
 	return hook, resp, err
 }
 
@@ -49,7 +52,7 @@ func (s *OrganizationsService) GetHook(org string, id int) (*Hook, *Response, er
 // Name and Config are required fields.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/hooks/#create-a-hook
-func (s *OrganizationsService) CreateHook(org string, hook *Hook) (*Hook, *Response, error) {
+func (s *OrganizationsService) CreateHook(ctx context.Context, org string, hook *Hook) (*Hook, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/hooks", org)
 	req, err := s.client.NewRequest("POST", u, hook)
 	if err != nil {
@@ -57,48 +60,48 @@ func (s *OrganizationsService) CreateHook(org string, hook *Hook) (*Hook, *Respo
 	}
 
 	h := new(Hook)
-	resp, err := s.client.Do(req, h)
+	resp, err := s.client.Do(ctx, req, h)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return h, resp, err
+	return h, resp, nil
 }
 
 // EditHook updates a specified Hook.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/hooks/#edit-a-hook
-func (s *OrganizationsService) EditHook(org string, id int, hook *Hook) (*Hook, *Response, error) {
+func (s *OrganizationsService) EditHook(ctx context.Context, org string, id int, hook *Hook) (*Hook, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/hooks/%d", org, id)
 	req, err := s.client.NewRequest("PATCH", u, hook)
 	if err != nil {
 		return nil, nil, err
 	}
 	h := new(Hook)
-	resp, err := s.client.Do(req, h)
+	resp, err := s.client.Do(ctx, req, h)
 	return h, resp, err
 }
 
 // PingHook triggers a 'ping' event to be sent to the Hook.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/hooks/#ping-a-hook
-func (s *OrganizationsService) PingHook(org string, id int) (*Response, error) {
+func (s *OrganizationsService) PingHook(ctx context.Context, org string, id int) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/hooks/%d/pings", org, id)
 	req, err := s.client.NewRequest("POST", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // DeleteHook deletes a specified Hook.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/hooks/#delete-a-hook
-func (s *OrganizationsService) DeleteHook(org string, id int) (*Response, error) {
+func (s *OrganizationsService) DeleteHook(ctx context.Context, org string, id int) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/hooks/%d", org, id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/orgs_members.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Membership represents the status of a user's membership in an organization or team.
 type Membership struct {
@@ -48,8 +51,8 @@ type ListMembersOptions struct {
 	// organization), list only publicly visible members.
 	PublicOnly bool `url:"-"`
 
-	// Filter members returned in the list.  Possible values are:
-	// 2fa_disabled, all.  Default is "all".
+	// Filter members returned in the list. Possible values are:
+	// 2fa_disabled, all. Default is "all".
 	Filter string `url:"filter,omitempty"`
 
 	// Role filters members returned by their role in the organization.
@@ -64,12 +67,12 @@ type ListMembersOptions struct {
 	ListOptions
 }
 
-// ListMembers lists the members for an organization.  If the authenticated
+// ListMembers lists the members for an organization. If the authenticated
 // user is an owner of the organization, this will return both concealed and
 // public members, otherwise it will only return public members.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/members/#members-list
-func (s *OrganizationsService) ListMembers(org string, opt *ListMembersOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#members-list
+func (s *OrganizationsService) ListMembers(ctx context.Context, org string, opt *ListMembersOptions) ([]*User, *Response, error) {
 	var u string
 	if opt != nil && opt.PublicOnly {
 		u = fmt.Sprintf("orgs/%v/public_members", org)
@@ -86,83 +89,83 @@ func (s *OrganizationsService) ListMembers(org string, opt *ListMembersOptions)
 		return nil, nil, err
 	}
 
-	members := new([]*User)
-	resp, err := s.client.Do(req, members)
+	var members []*User
+	resp, err := s.client.Do(ctx, req, &members)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *members, resp, err
+	return members, resp, nil
 }
 
 // IsMember checks if a user is a member of an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/members/#check-membership
-func (s *OrganizationsService) IsMember(org, user string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#check-membership
+func (s *OrganizationsService) IsMember(ctx context.Context, org, user string) (bool, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/members/%v", org, user)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
 
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	member, err := parseBoolResponse(err)
 	return member, resp, err
 }
 
 // IsPublicMember checks if a user is a public member of an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/members/#check-public-membership
-func (s *OrganizationsService) IsPublicMember(org, user string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#check-public-membership
+func (s *OrganizationsService) IsPublicMember(ctx context.Context, org, user string) (bool, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/public_members/%v", org, user)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
 
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	member, err := parseBoolResponse(err)
 	return member, resp, err
 }
 
 // RemoveMember removes a user from all teams of an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/members/#remove-a-member
-func (s *OrganizationsService) RemoveMember(org, user string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#remove-a-member
+func (s *OrganizationsService) RemoveMember(ctx context.Context, org, user string) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/members/%v", org, user)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // PublicizeMembership publicizes a user's membership in an organization. (A
 // user cannot publicize the membership for another user.)
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/members/#publicize-a-users-membership
-func (s *OrganizationsService) PublicizeMembership(org, user string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#publicize-a-users-membership
+func (s *OrganizationsService) PublicizeMembership(ctx context.Context, org, user string) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/public_members/%v", org, user)
 	req, err := s.client.NewRequest("PUT", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ConcealMembership conceals a user's membership in an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/members/#conceal-a-users-membership
-func (s *OrganizationsService) ConcealMembership(org, user string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#conceal-a-users-membership
+func (s *OrganizationsService) ConcealMembership(ctx context.Context, org, user string) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/public_members/%v", org, user)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ListOrgMembershipsOptions specifies optional parameters to the
@@ -178,7 +181,7 @@ type ListOrgMembershipsOptions struct {
 // ListOrgMemberships lists the organization memberships for the authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/members/#list-your-organization-memberships
-func (s *OrganizationsService) ListOrgMemberships(opt *ListOrgMembershipsOptions) ([]*Membership, *Response, error) {
+func (s *OrganizationsService) ListOrgMemberships(ctx context.Context, opt *ListOrgMembershipsOptions) ([]*Membership, *Response, error) {
 	u := "user/memberships/orgs"
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -191,21 +194,22 @@ func (s *OrganizationsService) ListOrgMemberships(opt *ListOrgMembershipsOptions
 	}
 
 	var memberships []*Membership
-	resp, err := s.client.Do(req, &memberships)
+	resp, err := s.client.Do(ctx, req, &memberships)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return memberships, resp, err
+	return memberships, resp, nil
 }
 
 // GetOrgMembership gets the membership for a user in a specified organization.
 // Passing an empty string for user will get the membership for the
 // authenticated user.
 //
-// GitHub API docs: https://developer.github.com/v3/orgs/members/#get-organization-membership
-// GitHub API docs: https://developer.github.com/v3/orgs/members/#get-your-organization-membership
-func (s *OrganizationsService) GetOrgMembership(user, org string) (*Membership, *Response, error) {
+// GitHub API docs:
+// https://developer.github.com/v3/orgs/members/#get-organization-membership
+// https://developer.github.com/v3/orgs/members/#get-your-organization-membership
+func (s *OrganizationsService) GetOrgMembership(ctx context.Context, user, org string) (*Membership, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("orgs/%v/memberships/%v", org, user)
@@ -219,12 +223,12 @@ func (s *OrganizationsService) GetOrgMembership(user, org string) (*Membership,
 	}
 
 	membership := new(Membership)
-	resp, err := s.client.Do(req, membership)
+	resp, err := s.client.Do(ctx, req, membership)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return membership, resp, err
+	return membership, resp, nil
 }
 
 // EditOrgMembership edits the membership for user in specified organization.
@@ -233,7 +237,7 @@ func (s *OrganizationsService) GetOrgMembership(user, org string) (*Membership,
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/members/#add-or-update-organization-membership
 // GitHub API docs: https://developer.github.com/v3/orgs/members/#edit-your-organization-membership
-func (s *OrganizationsService) EditOrgMembership(user, org string, membership *Membership) (*Membership, *Response, error) {
+func (s *OrganizationsService) EditOrgMembership(ctx context.Context, user, org string, membership *Membership) (*Membership, *Response, error) {
 	var u, method string
 	if user != "" {
 		u = fmt.Sprintf("orgs/%v/memberships/%v", org, user)
@@ -249,24 +253,47 @@ func (s *OrganizationsService) EditOrgMembership(user, org string, membership *M
 	}
 
 	m := new(Membership)
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return m, resp, err
+	return m, resp, nil
 }
 
-// RemoveOrgMembership removes user from the specified organization.  If the
+// RemoveOrgMembership removes user from the specified organization. If the
 // user has been invited to the organization, this will cancel their invitation.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/members/#remove-organization-membership
-func (s *OrganizationsService) RemoveOrgMembership(user, org string) (*Response, error) {
+func (s *OrganizationsService) RemoveOrgMembership(ctx context.Context, user, org string) (*Response, error) {
 	u := fmt.Sprintf("orgs/%v/memberships/%v", org, user)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListPendingOrgInvitations returns a list of pending invitations.
+//
+// GitHub API docs: https://developer.github.com/v3/orgs/members/#list-pending-organization-invitations
+func (s *OrganizationsService) ListPendingOrgInvitations(ctx context.Context, org int, opt *ListOptions) ([]*Invitation, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/invitations", org)
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var pendingInvitations []*Invitation
+	resp, err := s.client.Do(ctx, req, &pendingInvitations)
+	if err != nil {
+		return nil, resp, err
+	}
+	return pendingInvitations, resp, nil
 }

vendor/github.com/google/go-github/github/orgs_outside_collaborators.go

@@ -0,0 +1,50 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListOutsideCollaboratorsOptions specifies optional parameters to the
+// OrganizationsService.ListOutsideCollaborators method.
+type ListOutsideCollaboratorsOptions struct {
+	// Filter outside collaborators returned in the list. Possible values are:
+	// 2fa_disabled, all.  Default is "all".
+	Filter string `url:"filter,omitempty"`
+
+	ListOptions
+}
+
+// ListOutsideCollaborators lists outside collaborators of organization's repositories.
+// This will only work if the authenticated
+// user is an owner of the organization.
+//
+// Warning: The API may change without advance notice during the preview period.
+// Preview features are not supported for production use.
+//
+// GitHub API docs: https://developer.github.com/v3/orgs/outside_collaborators/#list-outside-collaborators
+func (s *OrganizationsService) ListOutsideCollaborators(ctx context.Context, org string, opt *ListOutsideCollaboratorsOptions) ([]*User, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/outside_collaborators", org)
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var members []*User
+	resp, err := s.client.Do(ctx, req, &members)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return members, resp, nil
+}

vendor/github.com/google/go-github/github/orgs_projects.go

@@ -0,0 +1,60 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListProjects lists the projects for an organization.
+//
+// GitHub API docs: https://developer.github.com/v3/projects/#list-organization-projects
+func (s *OrganizationsService) ListProjects(ctx context.Context, org string, opt *ProjectListOptions) ([]*Project, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/projects", org)
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeProjectsPreview)
+
+	var projects []*Project
+	resp, err := s.client.Do(ctx, req, &projects)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return projects, resp, nil
+}
+
+// CreateProject creates a GitHub Project for the specified organization.
+//
+// GitHub API docs: https://developer.github.com/v3/projects/#create-an-organization-project
+func (s *OrganizationsService) CreateProject(ctx context.Context, org string, opt *ProjectOptions) (*Project, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/projects", org)
+	req, err := s.client.NewRequest("POST", u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeProjectsPreview)
+
+	project := &Project{}
+	resp, err := s.client.Do(ctx, req, project)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return project, resp, nil
+}

vendor/github.com/google/go-github/github/orgs_teams.go

@@ -5,9 +5,13 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+	"time"
+)
 
-// Team represents a team within a GitHub organization.  Teams are used to
+// Team represents a team within a GitHub organization. Teams are used to
 // manage access to an organization's repositories.
 type Team struct {
 	ID          *int    `json:"id,omitempty"`
@@ -17,9 +21,9 @@ type Team struct {
 	Slug        *string `json:"slug,omitempty"`
 
 	// Permission is deprecated when creating or editing a team in an org
-	// using the new GitHub permission model.  It no longer identifies the
+	// using the new GitHub permission model. It no longer identifies the
 	// permission a team has on its repos, but only specifies the default
-	// permission a repo is initially added with.  Avoid confusion by
+	// permission a repo is initially added with. Avoid confusion by
 	// specifying a permission value when calling AddTeamRepo.
 	Permission *string `json:"permission,omitempty"`
 
@@ -35,16 +39,35 @@ type Team struct {
 	Organization    *Organization `json:"organization,omitempty"`
 	MembersURL      *string       `json:"members_url,omitempty"`
 	RepositoriesURL *string       `json:"repositories_url,omitempty"`
+
+	// LDAPDN is only available in GitHub Enterprise and when the team
+	// membership is synchronized with LDAP.
+	LDAPDN *string `json:"ldap_dn,omitempty"`
 }
 
 func (t Team) String() string {
 	return Stringify(t)
 }
 
+// Invitation represents a team member's invitation status.
+type Invitation struct {
+	ID    *int    `json:"id,omitempty"`
+	Login *string `json:"login,omitempty"`
+	Email *string `json:"email,omitempty"`
+	// Role can be one of the values - 'direct_member', 'admin', 'billing_manager', 'hiring_manager', or 'reinstate'.
+	Role      *string    `json:"role,omitempty"`
+	CreatedAt *time.Time `json:"created_at,omitempty"`
+	Inviter   *User      `json:"inviter,omitempty"`
+}
+
+func (i Invitation) String() string {
+	return Stringify(i)
+}
+
 // ListTeams lists all of the teams for an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#list-teams
-func (s *OrganizationsService) ListTeams(org string, opt *ListOptions) ([]*Team, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#list-teams
+func (s *OrganizationsService) ListTeams(ctx context.Context, org string, opt *ListOptions) ([]*Team, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/teams", org)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -56,19 +79,19 @@ func (s *OrganizationsService) ListTeams(org string, opt *ListOptions) ([]*Team,
 		return nil, nil, err
 	}
 
-	teams := new([]*Team)
-	resp, err := s.client.Do(req, teams)
+	var teams []*Team
+	resp, err := s.client.Do(ctx, req, &teams)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *teams, resp, err
+	return teams, resp, nil
 }
 
 // GetTeam fetches a team by ID.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#get-team
-func (s *OrganizationsService) GetTeam(team int) (*Team, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#get-team
+func (s *OrganizationsService) GetTeam(ctx context.Context, team int) (*Team, *Response, error) {
 	u := fmt.Sprintf("teams/%v", team)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -76,18 +99,18 @@ func (s *OrganizationsService) GetTeam(team int) (*Team, *Response, error) {
 	}
 
 	t := new(Team)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }
 
 // CreateTeam creates a new team within an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#create-team
-func (s *OrganizationsService) CreateTeam(org string, team *Team) (*Team, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#create-team
+func (s *OrganizationsService) CreateTeam(ctx context.Context, org string, team *Team) (*Team, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/teams", org)
 	req, err := s.client.NewRequest("POST", u, team)
 	if err != nil {
@@ -95,18 +118,18 @@ func (s *OrganizationsService) CreateTeam(org string, team *Team) (*Team, *Respo
 	}
 
 	t := new(Team)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }
 
 // EditTeam edits a team.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#edit-team
-func (s *OrganizationsService) EditTeam(id int, team *Team) (*Team, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#edit-team
+func (s *OrganizationsService) EditTeam(ctx context.Context, id int, team *Team) (*Team, *Response, error) {
 	u := fmt.Sprintf("teams/%v", id)
 	req, err := s.client.NewRequest("PATCH", u, team)
 	if err != nil {
@@ -114,32 +137,32 @@ func (s *OrganizationsService) EditTeam(id int, team *Team) (*Team, *Response, e
 	}
 
 	t := new(Team)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }
 
 // DeleteTeam deletes a team.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#delete-team
-func (s *OrganizationsService) DeleteTeam(team int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#delete-team
+func (s *OrganizationsService) DeleteTeam(ctx context.Context, team int) (*Response, error) {
 	u := fmt.Sprintf("teams/%v", team)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // OrganizationListTeamMembersOptions specifies the optional parameters to the
 // OrganizationsService.ListTeamMembers method.
 type OrganizationListTeamMembersOptions struct {
-	// Role filters members returned by their role in the team.  Possible
-	// values are "all", "member", "maintainer".  Default is "all".
+	// Role filters members returned by their role in the team. Possible
+	// values are "all", "member", "maintainer". Default is "all".
 	Role string `url:"role,omitempty"`
 
 	ListOptions
@@ -148,8 +171,8 @@ type OrganizationListTeamMembersOptions struct {
 // ListTeamMembers lists all of the users who are members of the specified
 // team.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#list-team-members
-func (s *OrganizationsService) ListTeamMembers(team int, opt *OrganizationListTeamMembersOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#list-team-members
+func (s *OrganizationsService) ListTeamMembers(ctx context.Context, team int, opt *OrganizationListTeamMembersOptions) ([]*User, *Response, error) {
 	u := fmt.Sprintf("teams/%v/members", team)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -161,34 +184,34 @@ func (s *OrganizationsService) ListTeamMembers(team int, opt *OrganizationListTe
 		return nil, nil, err
 	}
 
-	members := new([]*User)
-	resp, err := s.client.Do(req, members)
+	var members []*User
+	resp, err := s.client.Do(ctx, req, &members)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *members, resp, err
+	return members, resp, nil
 }
 
 // IsTeamMember checks if a user is a member of the specified team.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#get-team-member
-func (s *OrganizationsService) IsTeamMember(team int, user string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#get-team-member
+func (s *OrganizationsService) IsTeamMember(ctx context.Context, team int, user string) (bool, *Response, error) {
 	u := fmt.Sprintf("teams/%v/members/%v", team, user)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
 
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	member, err := parseBoolResponse(err)
 	return member, resp, err
 }
 
 // ListTeamRepos lists the repositories that the specified team has access to.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#list-team-repos
-func (s *OrganizationsService) ListTeamRepos(team int, opt *ListOptions) ([]*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#list-team-repos
+func (s *OrganizationsService) ListTeamRepos(ctx context.Context, team int, opt *ListOptions) ([]*Repository, *Response, error) {
 	u := fmt.Sprintf("teams/%v/repos", team)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -200,21 +223,21 @@ func (s *OrganizationsService) ListTeamRepos(team int, opt *ListOptions) ([]*Rep
 		return nil, nil, err
 	}
 
-	repos := new([]*Repository)
-	resp, err := s.client.Do(req, repos)
+	var repos []*Repository
+	resp, err := s.client.Do(ctx, req, &repos)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *repos, resp, err
+	return repos, resp, nil
 }
 
-// IsTeamRepo checks if a team manages the specified repository.  If the
+// IsTeamRepo checks if a team manages the specified repository. If the
 // repository is managed by team, a Repository is returned which includes the
 // permissions team has for that repo.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/teams/#check-if-a-team-manages-a-repository
-func (s *OrganizationsService) IsTeamRepo(team int, owner string, repo string) (*Repository, *Response, error) {
+func (s *OrganizationsService) IsTeamRepo(ctx context.Context, team int, owner string, repo string) (*Repository, *Response, error) {
 	u := fmt.Sprintf("teams/%v/repos/%v/%v", team, owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -224,12 +247,12 @@ func (s *OrganizationsService) IsTeamRepo(team int, owner string, repo string) (
 	req.Header.Set("Accept", mediaTypeOrgPermissionRepo)
 
 	repository := new(Repository)
-	resp, err := s.client.Do(req, repository)
+	resp, err := s.client.Do(ctx, req, repository)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return repository, resp, err
+	return repository, resp, nil
 }
 
 // OrganizationAddTeamRepoOptions specifies the optional parameters to the
@@ -245,39 +268,39 @@ type OrganizationAddTeamRepoOptions struct {
 	Permission string `json:"permission,omitempty"`
 }
 
-// AddTeamRepo adds a repository to be managed by the specified team.  The
+// AddTeamRepo adds a repository to be managed by the specified team. The
 // specified repository must be owned by the organization to which the team
 // belongs, or a direct fork of a repository owned by the organization.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#add-team-repo
-func (s *OrganizationsService) AddTeamRepo(team int, owner string, repo string, opt *OrganizationAddTeamRepoOptions) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#add-team-repo
+func (s *OrganizationsService) AddTeamRepo(ctx context.Context, team int, owner string, repo string, opt *OrganizationAddTeamRepoOptions) (*Response, error) {
 	u := fmt.Sprintf("teams/%v/repos/%v/%v", team, owner, repo)
 	req, err := s.client.NewRequest("PUT", u, opt)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // RemoveTeamRepo removes a repository from being managed by the specified
-// team.  Note that this does not delete the repository, it just removes it
+// team. Note that this does not delete the repository, it just removes it
 // from the team.
 //
-// GitHub API docs: http://developer.github.com/v3/orgs/teams/#remove-team-repo
-func (s *OrganizationsService) RemoveTeamRepo(team int, owner string, repo string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#remove-team-repo
+func (s *OrganizationsService) RemoveTeamRepo(ctx context.Context, team int, owner string, repo string) (*Response, error) {
 	u := fmt.Sprintf("teams/%v/repos/%v/%v", team, owner, repo)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ListUserTeams lists a user's teams
 // GitHub API docs: https://developer.github.com/v3/orgs/teams/#list-user-teams
-func (s *OrganizationsService) ListUserTeams(opt *ListOptions) ([]*Team, *Response, error) {
+func (s *OrganizationsService) ListUserTeams(ctx context.Context, opt *ListOptions) ([]*Team, *Response, error) {
 	u := "user/teams"
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -289,19 +312,19 @@ func (s *OrganizationsService) ListUserTeams(opt *ListOptions) ([]*Team, *Respon
 		return nil, nil, err
 	}
 
-	teams := new([]*Team)
-	resp, err := s.client.Do(req, teams)
+	var teams []*Team
+	resp, err := s.client.Do(ctx, req, &teams)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *teams, resp, err
+	return teams, resp, nil
 }
 
 // GetTeamMembership returns the membership status for a user in a team.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/teams/#get-team-membership
-func (s *OrganizationsService) GetTeamMembership(team int, user string) (*Membership, *Response, error) {
+func (s *OrganizationsService) GetTeamMembership(ctx context.Context, team int, user string) (*Membership, *Response, error) {
 	u := fmt.Sprintf("teams/%v/memberships/%v", team, user)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -309,18 +332,18 @@ func (s *OrganizationsService) GetTeamMembership(team int, user string) (*Member
 	}
 
 	t := new(Membership)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }
 
 // OrganizationAddTeamMembershipOptions does stuff specifies the optional
 // parameters to the OrganizationsService.AddTeamMembership method.
 type OrganizationAddTeamMembershipOptions struct {
-	// Role specifies the role the user should have in the team.  Possible
+	// Role specifies the role the user should have in the team. Possible
 	// values are:
 	//     member - a normal member of the team
 	//     maintainer - a team maintainer. Able to add/remove other team
@@ -349,7 +372,7 @@ type OrganizationAddTeamMembershipOptions struct {
 // added as a member of the team.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/teams/#add-team-membership
-func (s *OrganizationsService) AddTeamMembership(team int, user string, opt *OrganizationAddTeamMembershipOptions) (*Membership, *Response, error) {
+func (s *OrganizationsService) AddTeamMembership(ctx context.Context, team int, user string, opt *OrganizationAddTeamMembershipOptions) (*Membership, *Response, error) {
 	u := fmt.Sprintf("teams/%v/memberships/%v", team, user)
 	req, err := s.client.NewRequest("PUT", u, opt)
 	if err != nil {
@@ -357,23 +380,49 @@ func (s *OrganizationsService) AddTeamMembership(team int, user string, opt *Org
 	}
 
 	t := new(Membership)
-	resp, err := s.client.Do(req, t)
+	resp, err := s.client.Do(ctx, req, t)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return t, resp, err
+	return t, resp, nil
 }
 
 // RemoveTeamMembership removes a user from a team.
 //
 // GitHub API docs: https://developer.github.com/v3/orgs/teams/#remove-team-membership
-func (s *OrganizationsService) RemoveTeamMembership(team int, user string) (*Response, error) {
+func (s *OrganizationsService) RemoveTeamMembership(ctx context.Context, team int, user string) (*Response, error) {
 	u := fmt.Sprintf("teams/%v/memberships/%v", team, user)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListPendingTeamInvitations get pending invitaion list in team.
+// Warning: The API may change without advance notice during the preview period.
+// Preview features are not supported for production use.
+//
+// GitHub API docs: https://developer.github.com/v3/orgs/teams/#list-pending-team-invitations
+func (s *OrganizationsService) ListPendingTeamInvitations(ctx context.Context, team int, opt *ListOptions) ([]*Invitation, *Response, error) {
+	u := fmt.Sprintf("teams/%v/invitations", team)
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var pendingInvitations []*Invitation
+	resp, err := s.client.Do(ctx, req, &pendingInvitations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return pendingInvitations, resp, nil
 }

vendor/github.com/google/go-github/github/projects.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // ProjectsService provides access to the projects functions in the
 // GitHub API.
@@ -35,7 +38,7 @@ func (p Project) String() string {
 // GetProject gets a GitHub Project for a repo.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/#get-a-project
-func (s *ProjectsService) GetProject(id int) (*Project, *Response, error) {
+func (s *ProjectsService) GetProject(ctx context.Context, id int) (*Project, *Response, error) {
 	u := fmt.Sprintf("projects/%v", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -46,12 +49,12 @@ func (s *ProjectsService) GetProject(id int) (*Project, *Response, error) {
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	project := &Project{}
-	resp, err := s.client.Do(req, project)
+	resp, err := s.client.Do(ctx, req, project)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return project, resp, err
+	return project, resp, nil
 }
 
 // ProjectOptions specifies the parameters to the
@@ -67,7 +70,7 @@ type ProjectOptions struct {
 // UpdateProject updates a repository project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/#update-a-project
-func (s *ProjectsService) UpdateProject(id int, opt *ProjectOptions) (*Project, *Response, error) {
+func (s *ProjectsService) UpdateProject(ctx context.Context, id int, opt *ProjectOptions) (*Project, *Response, error) {
 	u := fmt.Sprintf("projects/%v", id)
 	req, err := s.client.NewRequest("PATCH", u, opt)
 	if err != nil {
@@ -78,18 +81,18 @@ func (s *ProjectsService) UpdateProject(id int, opt *ProjectOptions) (*Project,
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	project := &Project{}
-	resp, err := s.client.Do(req, project)
+	resp, err := s.client.Do(ctx, req, project)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return project, resp, err
+	return project, resp, nil
 }
 
 // DeleteProject deletes a GitHub Project from a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/#delete-a-project
-func (s *ProjectsService) DeleteProject(id int) (*Response, error) {
+func (s *ProjectsService) DeleteProject(ctx context.Context, id int) (*Response, error) {
 	u := fmt.Sprintf("projects/%v", id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -99,7 +102,7 @@ func (s *ProjectsService) DeleteProject(id int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ProjectColumn represents a column of a GitHub Project.
@@ -116,7 +119,7 @@ type ProjectColumn struct {
 // ListProjectColumns lists the columns of a GitHub Project for a repo.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/columns/#list-project-columns
-func (s *ProjectsService) ListProjectColumns(projectID int, opt *ListOptions) ([]*ProjectColumn, *Response, error) {
+func (s *ProjectsService) ListProjectColumns(ctx context.Context, projectID int, opt *ListOptions) ([]*ProjectColumn, *Response, error) {
 	u := fmt.Sprintf("projects/%v/columns", projectID)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -132,18 +135,18 @@ func (s *ProjectsService) ListProjectColumns(projectID int, opt *ListOptions) ([
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	columns := []*ProjectColumn{}
-	resp, err := s.client.Do(req, &columns)
+	resp, err := s.client.Do(ctx, req, &columns)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return columns, resp, err
+	return columns, resp, nil
 }
 
 // GetProjectColumn gets a column of a GitHub Project for a repo.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/columns/#get-a-project-column
-func (s *ProjectsService) GetProjectColumn(id int) (*ProjectColumn, *Response, error) {
+func (s *ProjectsService) GetProjectColumn(ctx context.Context, id int) (*ProjectColumn, *Response, error) {
 	u := fmt.Sprintf("projects/columns/%v", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -154,12 +157,12 @@ func (s *ProjectsService) GetProjectColumn(id int) (*ProjectColumn, *Response, e
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	column := &ProjectColumn{}
-	resp, err := s.client.Do(req, column)
+	resp, err := s.client.Do(ctx, req, column)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return column, resp, err
+	return column, resp, nil
 }
 
 // ProjectColumnOptions specifies the parameters to the
@@ -173,7 +176,7 @@ type ProjectColumnOptions struct {
 // CreateProjectColumn creates a column for the specified (by number) project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/columns/#create-a-project-column
-func (s *ProjectsService) CreateProjectColumn(projectID int, opt *ProjectColumnOptions) (*ProjectColumn, *Response, error) {
+func (s *ProjectsService) CreateProjectColumn(ctx context.Context, projectID int, opt *ProjectColumnOptions) (*ProjectColumn, *Response, error) {
 	u := fmt.Sprintf("projects/%v/columns", projectID)
 	req, err := s.client.NewRequest("POST", u, opt)
 	if err != nil {
@@ -184,18 +187,18 @@ func (s *ProjectsService) CreateProjectColumn(projectID int, opt *ProjectColumnO
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	column := &ProjectColumn{}
-	resp, err := s.client.Do(req, column)
+	resp, err := s.client.Do(ctx, req, column)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return column, resp, err
+	return column, resp, nil
 }
 
 // UpdateProjectColumn updates a column of a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/columns/#update-a-project-column
-func (s *ProjectsService) UpdateProjectColumn(columnID int, opt *ProjectColumnOptions) (*ProjectColumn, *Response, error) {
+func (s *ProjectsService) UpdateProjectColumn(ctx context.Context, columnID int, opt *ProjectColumnOptions) (*ProjectColumn, *Response, error) {
 	u := fmt.Sprintf("projects/columns/%v", columnID)
 	req, err := s.client.NewRequest("PATCH", u, opt)
 	if err != nil {
@@ -206,18 +209,18 @@ func (s *ProjectsService) UpdateProjectColumn(columnID int, opt *ProjectColumnOp
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	column := &ProjectColumn{}
-	resp, err := s.client.Do(req, column)
+	resp, err := s.client.Do(ctx, req, column)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return column, resp, err
+	return column, resp, nil
 }
 
 // DeleteProjectColumn deletes a column from a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/columns/#delete-a-project-column
-func (s *ProjectsService) DeleteProjectColumn(columnID int) (*Response, error) {
+func (s *ProjectsService) DeleteProjectColumn(ctx context.Context, columnID int) (*Response, error) {
 	u := fmt.Sprintf("projects/columns/%v", columnID)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -227,7 +230,7 @@ func (s *ProjectsService) DeleteProjectColumn(columnID int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ProjectColumnMoveOptions specifies the parameters to the
@@ -241,7 +244,7 @@ type ProjectColumnMoveOptions struct {
 // MoveProjectColumn moves a column within a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/columns/#move-a-project-column
-func (s *ProjectsService) MoveProjectColumn(columnID int, opt *ProjectColumnMoveOptions) (*Response, error) {
+func (s *ProjectsService) MoveProjectColumn(ctx context.Context, columnID int, opt *ProjectColumnMoveOptions) (*Response, error) {
 	u := fmt.Sprintf("projects/columns/%v/moves", columnID)
 	req, err := s.client.NewRequest("POST", u, opt)
 	if err != nil {
@@ -251,7 +254,7 @@ func (s *ProjectsService) MoveProjectColumn(columnID int, opt *ProjectColumnMove
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ProjectCard represents a card in a column of a GitHub Project.
@@ -269,7 +272,7 @@ type ProjectCard struct {
 // ListProjectCards lists the cards in a column of a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/cards/#list-project-cards
-func (s *ProjectsService) ListProjectCards(columnID int, opt *ListOptions) ([]*ProjectCard, *Response, error) {
+func (s *ProjectsService) ListProjectCards(ctx context.Context, columnID int, opt *ListOptions) ([]*ProjectCard, *Response, error) {
 	u := fmt.Sprintf("projects/columns/%v/cards", columnID)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -285,18 +288,18 @@ func (s *ProjectsService) ListProjectCards(columnID int, opt *ListOptions) ([]*P
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	cards := []*ProjectCard{}
-	resp, err := s.client.Do(req, &cards)
+	resp, err := s.client.Do(ctx, req, &cards)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return cards, resp, err
+	return cards, resp, nil
 }
 
 // GetProjectCard gets a card in a column of a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/cards/#get-a-project-card
-func (s *ProjectsService) GetProjectCard(columnID int) (*ProjectCard, *Response, error) {
+func (s *ProjectsService) GetProjectCard(ctx context.Context, columnID int) (*ProjectCard, *Response, error) {
 	u := fmt.Sprintf("projects/columns/cards/%v", columnID)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -307,12 +310,12 @@ func (s *ProjectsService) GetProjectCard(columnID int) (*ProjectCard, *Response,
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	card := &ProjectCard{}
-	resp, err := s.client.Do(req, card)
+	resp, err := s.client.Do(ctx, req, card)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return card, resp, err
+	return card, resp, nil
 }
 
 // ProjectCardOptions specifies the parameters to the
@@ -331,7 +334,7 @@ type ProjectCardOptions struct {
 // CreateProjectCard creates a card in the specified column of a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/cards/#create-a-project-card
-func (s *ProjectsService) CreateProjectCard(columnID int, opt *ProjectCardOptions) (*ProjectCard, *Response, error) {
+func (s *ProjectsService) CreateProjectCard(ctx context.Context, columnID int, opt *ProjectCardOptions) (*ProjectCard, *Response, error) {
 	u := fmt.Sprintf("projects/columns/%v/cards", columnID)
 	req, err := s.client.NewRequest("POST", u, opt)
 	if err != nil {
@@ -342,18 +345,18 @@ func (s *ProjectsService) CreateProjectCard(columnID int, opt *ProjectCardOption
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	card := &ProjectCard{}
-	resp, err := s.client.Do(req, card)
+	resp, err := s.client.Do(ctx, req, card)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return card, resp, err
+	return card, resp, nil
 }
 
 // UpdateProjectCard updates a card of a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/cards/#update-a-project-card
-func (s *ProjectsService) UpdateProjectCard(cardID int, opt *ProjectCardOptions) (*ProjectCard, *Response, error) {
+func (s *ProjectsService) UpdateProjectCard(ctx context.Context, cardID int, opt *ProjectCardOptions) (*ProjectCard, *Response, error) {
 	u := fmt.Sprintf("projects/columns/cards/%v", cardID)
 	req, err := s.client.NewRequest("PATCH", u, opt)
 	if err != nil {
@@ -364,18 +367,18 @@ func (s *ProjectsService) UpdateProjectCard(cardID int, opt *ProjectCardOptions)
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	card := &ProjectCard{}
-	resp, err := s.client.Do(req, card)
+	resp, err := s.client.Do(ctx, req, card)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return card, resp, err
+	return card, resp, nil
 }
 
 // DeleteProjectCard deletes a card from a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/cards/#delete-a-project-card
-func (s *ProjectsService) DeleteProjectCard(cardID int) (*Response, error) {
+func (s *ProjectsService) DeleteProjectCard(ctx context.Context, cardID int) (*Response, error) {
 	u := fmt.Sprintf("projects/columns/cards/%v", cardID)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -385,7 +388,7 @@ func (s *ProjectsService) DeleteProjectCard(cardID int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ProjectCardMoveOptions specifies the parameters to the
@@ -403,7 +406,7 @@ type ProjectCardMoveOptions struct {
 // MoveProjectCard moves a card within a GitHub Project.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/cards/#move-a-project-card
-func (s *ProjectsService) MoveProjectCard(cardID int, opt *ProjectCardMoveOptions) (*Response, error) {
+func (s *ProjectsService) MoveProjectCard(ctx context.Context, cardID int, opt *ProjectCardMoveOptions) (*Response, error) {
 	u := fmt.Sprintf("projects/columns/cards/%v/moves", cardID)
 	req, err := s.client.NewRequest("POST", u, opt)
 	if err != nil {
@@ -413,5 +416,5 @@ func (s *ProjectsService) MoveProjectCard(cardID int, opt *ProjectCardMoveOption
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/pulls.go

@@ -7,6 +7,7 @@ package github
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"time"
 )
@@ -14,40 +15,41 @@ import (
 // PullRequestsService handles communication with the pull request related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/pulls/
+// GitHub API docs: https://developer.github.com/v3/pulls/
 type PullRequestsService service
 
 // PullRequest represents a GitHub pull request on a repository.
 type PullRequest struct {
-	ID                *int       `json:"id,omitempty"`
-	Number            *int       `json:"number,omitempty"`
-	State             *string    `json:"state,omitempty"`
-	Title             *string    `json:"title,omitempty"`
-	Body              *string    `json:"body,omitempty"`
-	CreatedAt         *time.Time `json:"created_at,omitempty"`
-	UpdatedAt         *time.Time `json:"updated_at,omitempty"`
-	ClosedAt          *time.Time `json:"closed_at,omitempty"`
-	MergedAt          *time.Time `json:"merged_at,omitempty"`
-	User              *User      `json:"user,omitempty"`
-	Merged            *bool      `json:"merged,omitempty"`
-	Mergeable         *bool      `json:"mergeable,omitempty"`
-	MergedBy          *User      `json:"merged_by,omitempty"`
-	Comments          *int       `json:"comments,omitempty"`
-	Commits           *int       `json:"commits,omitempty"`
-	Additions         *int       `json:"additions,omitempty"`
-	Deletions         *int       `json:"deletions,omitempty"`
-	ChangedFiles      *int       `json:"changed_files,omitempty"`
-	URL               *string    `json:"url,omitempty"`
-	HTMLURL           *string    `json:"html_url,omitempty"`
-	IssueURL          *string    `json:"issue_url,omitempty"`
-	StatusesURL       *string    `json:"statuses_url,omitempty"`
-	DiffURL           *string    `json:"diff_url,omitempty"`
-	PatchURL          *string    `json:"patch_url,omitempty"`
-	ReviewCommentsURL *string    `json:"review_comments_url,omitempty"`
-	ReviewCommentURL  *string    `json:"review_comment_url,omitempty"`
-	Assignee          *User      `json:"assignee,omitempty"`
-	Assignees         []*User    `json:"assignees,omitempty"`
-	Milestone         *Milestone `json:"milestone,omitempty"`
+	ID                  *int       `json:"id,omitempty"`
+	Number              *int       `json:"number,omitempty"`
+	State               *string    `json:"state,omitempty"`
+	Title               *string    `json:"title,omitempty"`
+	Body                *string    `json:"body,omitempty"`
+	CreatedAt           *time.Time `json:"created_at,omitempty"`
+	UpdatedAt           *time.Time `json:"updated_at,omitempty"`
+	ClosedAt            *time.Time `json:"closed_at,omitempty"`
+	MergedAt            *time.Time `json:"merged_at,omitempty"`
+	User                *User      `json:"user,omitempty"`
+	Merged              *bool      `json:"merged,omitempty"`
+	Mergeable           *bool      `json:"mergeable,omitempty"`
+	MergedBy            *User      `json:"merged_by,omitempty"`
+	Comments            *int       `json:"comments,omitempty"`
+	Commits             *int       `json:"commits,omitempty"`
+	Additions           *int       `json:"additions,omitempty"`
+	Deletions           *int       `json:"deletions,omitempty"`
+	ChangedFiles        *int       `json:"changed_files,omitempty"`
+	URL                 *string    `json:"url,omitempty"`
+	HTMLURL             *string    `json:"html_url,omitempty"`
+	IssueURL            *string    `json:"issue_url,omitempty"`
+	StatusesURL         *string    `json:"statuses_url,omitempty"`
+	DiffURL             *string    `json:"diff_url,omitempty"`
+	PatchURL            *string    `json:"patch_url,omitempty"`
+	ReviewCommentsURL   *string    `json:"review_comments_url,omitempty"`
+	ReviewCommentURL    *string    `json:"review_comment_url,omitempty"`
+	Assignee            *User      `json:"assignee,omitempty"`
+	Assignees           []*User    `json:"assignees,omitempty"`
+	Milestone           *Milestone `json:"milestone,omitempty"`
+	MaintainerCanModify *bool      `json:"maintainer_can_modify,omitempty"`
 
 	Head *PullRequestBranch `json:"head,omitempty"`
 	Base *PullRequestBranch `json:"base,omitempty"`
@@ -69,8 +71,8 @@ type PullRequestBranch struct {
 // PullRequestListOptions specifies the optional parameters to the
 // PullRequestsService.List method.
 type PullRequestListOptions struct {
-	// State filters pull requests based on their state.  Possible values are:
-	// open, closed.  Default is "open".
+	// State filters pull requests based on their state. Possible values are:
+	// open, closed. Default is "open".
 	State string `url:"state,omitempty"`
 
 	// Head filters pull requests by head user and branch name in the format of:
@@ -94,8 +96,8 @@ type PullRequestListOptions struct {
 
 // List the pull requests for the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/pulls/#list-pull-requests
-func (s *PullRequestsService) List(owner string, repo string, opt *PullRequestListOptions) ([]*PullRequest, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/pulls/#list-pull-requests
+func (s *PullRequestsService) List(ctx context.Context, owner string, repo string, opt *PullRequestListOptions) ([]*PullRequest, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -107,19 +109,19 @@ func (s *PullRequestsService) List(owner string, repo string, opt *PullRequestLi
 		return nil, nil, err
 	}
 
-	pulls := new([]*PullRequest)
-	resp, err := s.client.Do(req, pulls)
+	var pulls []*PullRequest
+	resp, err := s.client.Do(ctx, req, &pulls)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *pulls, resp, err
+	return pulls, resp, nil
 }
 
 // Get a single pull request.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#get-a-single-pull-request
-func (s *PullRequestsService) Get(owner string, repo string, number int) (*PullRequest, *Response, error) {
+func (s *PullRequestsService) Get(ctx context.Context, owner string, repo string, number int) (*PullRequest, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d", owner, repo, number)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -127,16 +129,16 @@ func (s *PullRequestsService) Get(owner string, repo string, number int) (*PullR
 	}
 
 	pull := new(PullRequest)
-	resp, err := s.client.Do(req, pull)
+	resp, err := s.client.Do(ctx, req, pull)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return pull, resp, err
+	return pull, resp, nil
 }
 
 // GetRaw gets raw (diff or patch) format of a pull request.
-func (s *PullRequestsService) GetRaw(owner string, repo string, number int, opt RawOptions) (string, *Response, error) {
+func (s *PullRequestsService) GetRaw(ctx context.Context, owner string, repo string, number int, opt RawOptions) (string, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d", owner, repo, number)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -153,27 +155,28 @@ func (s *PullRequestsService) GetRaw(owner string, repo string, number int, opt
 	}
 
 	ret := new(bytes.Buffer)
-	resp, err := s.client.Do(req, ret)
+	resp, err := s.client.Do(ctx, req, ret)
 	if err != nil {
 		return "", resp, err
 	}
 
-	return ret.String(), resp, err
+	return ret.String(), resp, nil
 }
 
 // NewPullRequest represents a new pull request to be created.
 type NewPullRequest struct {
-	Title *string `json:"title,omitempty"`
-	Head  *string `json:"head,omitempty"`
-	Base  *string `json:"base,omitempty"`
-	Body  *string `json:"body,omitempty"`
-	Issue *int    `json:"issue,omitempty"`
+	Title               *string `json:"title,omitempty"`
+	Head                *string `json:"head,omitempty"`
+	Base                *string `json:"base,omitempty"`
+	Body                *string `json:"body,omitempty"`
+	Issue               *int    `json:"issue,omitempty"`
+	MaintainerCanModify *bool   `json:"maintainer_can_modify,omitempty"`
 }
 
 // Create a new pull request on the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#create-a-pull-request
-func (s *PullRequestsService) Create(owner string, repo string, pull *NewPullRequest) (*PullRequest, *Response, error) {
+func (s *PullRequestsService) Create(ctx context.Context, owner string, repo string, pull *NewPullRequest) (*PullRequest, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls", owner, repo)
 	req, err := s.client.NewRequest("POST", u, pull)
 	if err != nil {
@@ -181,37 +184,64 @@ func (s *PullRequestsService) Create(owner string, repo string, pull *NewPullReq
 	}
 
 	p := new(PullRequest)
-	resp, err := s.client.Do(req, p)
+	resp, err := s.client.Do(ctx, req, p)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return p, resp, err
+	return p, resp, nil
+}
+
+type pullRequestUpdate struct {
+	Title               *string `json:"title,omitempty"`
+	Body                *string `json:"body,omitempty"`
+	State               *string `json:"state,omitempty"`
+	Base                *string `json:"base,omitempty"`
+	MaintainerCanModify *bool   `json:"maintainer_can_modify,omitempty"`
 }
 
 // Edit a pull request.
+// pull must not be nil.
+//
+// The following fields are editable: Title, Body, State, Base.Ref and MaintainerCanModify.
+// Base.Ref updates the base branch of the pull request.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#update-a-pull-request
-func (s *PullRequestsService) Edit(owner string, repo string, number int, pull *PullRequest) (*PullRequest, *Response, error) {
+func (s *PullRequestsService) Edit(ctx context.Context, owner string, repo string, number int, pull *PullRequest) (*PullRequest, *Response, error) {
+	if pull == nil {
+		return nil, nil, fmt.Errorf("pull must be provided")
+	}
+
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d", owner, repo, number)
-	req, err := s.client.NewRequest("PATCH", u, pull)
+
+	update := &pullRequestUpdate{
+		Title:               pull.Title,
+		Body:                pull.Body,
+		State:               pull.State,
+		MaintainerCanModify: pull.MaintainerCanModify,
+	}
+	if pull.Base != nil {
+		update.Base = pull.Base.Ref
+	}
+
+	req, err := s.client.NewRequest("PATCH", u, update)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	p := new(PullRequest)
-	resp, err := s.client.Do(req, p)
+	resp, err := s.client.Do(ctx, req, p)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return p, resp, err
+	return p, resp, nil
 }
 
 // ListCommits lists the commits in a pull request.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#list-commits-on-a-pull-request
-func (s *PullRequestsService) ListCommits(owner string, repo string, number int, opt *ListOptions) ([]*RepositoryCommit, *Response, error) {
+func (s *PullRequestsService) ListCommits(ctx context.Context, owner string, repo string, number int, opt *ListOptions) ([]*RepositoryCommit, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d/commits", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -223,19 +253,19 @@ func (s *PullRequestsService) ListCommits(owner string, repo string, number int,
 		return nil, nil, err
 	}
 
-	commits := new([]*RepositoryCommit)
-	resp, err := s.client.Do(req, commits)
+	var commits []*RepositoryCommit
+	resp, err := s.client.Do(ctx, req, &commits)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *commits, resp, err
+	return commits, resp, nil
 }
 
 // ListFiles lists the files in a pull request.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#list-pull-requests-files
-func (s *PullRequestsService) ListFiles(owner string, repo string, number int, opt *ListOptions) ([]*CommitFile, *Response, error) {
+func (s *PullRequestsService) ListFiles(ctx context.Context, owner string, repo string, number int, opt *ListOptions) ([]*CommitFile, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d/files", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -247,26 +277,26 @@ func (s *PullRequestsService) ListFiles(owner string, repo string, number int, o
 		return nil, nil, err
 	}
 
-	commitFiles := new([]*CommitFile)
-	resp, err := s.client.Do(req, commitFiles)
+	var commitFiles []*CommitFile
+	resp, err := s.client.Do(ctx, req, &commitFiles)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *commitFiles, resp, err
+	return commitFiles, resp, nil
 }
 
 // IsMerged checks if a pull request has been merged.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#get-if-a-pull-request-has-been-merged
-func (s *PullRequestsService) IsMerged(owner string, repo string, number int) (bool, *Response, error) {
+func (s *PullRequestsService) IsMerged(ctx context.Context, owner string, repo string, number int) (bool, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d/merge", owner, repo, number)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
 
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	merged, err := parseBoolResponse(err)
 	return merged, resp, err
 }
@@ -298,7 +328,7 @@ type pullRequestMergeRequest struct {
 // commitMessage is the title for the automatic commit message.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-buttontrade
-func (s *PullRequestsService) Merge(owner string, repo string, number int, commitMessage string, options *PullRequestOptions) (*PullRequestMergeResult, *Response, error) {
+func (s *PullRequestsService) Merge(ctx context.Context, owner string, repo string, number int, commitMessage string, options *PullRequestOptions) (*PullRequestMergeResult, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d/merge", owner, repo, number)
 
 	pullRequestBody := &pullRequestMergeRequest{CommitMessage: commitMessage}
@@ -316,10 +346,10 @@ func (s *PullRequestsService) Merge(owner string, repo string, number int, commi
 	req.Header.Set("Accept", mediaTypeSquashPreview)
 
 	mergeResult := new(PullRequestMergeResult)
-	resp, err := s.client.Do(req, mergeResult)
+	resp, err := s.client.Do(ctx, req, mergeResult)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return mergeResult, resp, err
+	return mergeResult, resp, nil
 }

vendor/github.com/google/go-github/github/pulls_comments.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -37,10 +38,10 @@ func (p PullRequestComment) String() string {
 // PullRequestListCommentsOptions specifies the optional parameters to the
 // PullRequestsService.ListComments method.
 type PullRequestListCommentsOptions struct {
-	// Sort specifies how to sort comments.  Possible values are: created, updated.
+	// Sort specifies how to sort comments. Possible values are: created, updated.
 	Sort string `url:"sort,omitempty"`
 
-	// Direction in which to sort comments.  Possible values are: asc, desc.
+	// Direction in which to sort comments. Possible values are: asc, desc.
 	Direction string `url:"direction,omitempty"`
 
 	// Since filters comments by time.
@@ -49,12 +50,12 @@ type PullRequestListCommentsOptions struct {
 	ListOptions
 }
 
-// ListComments lists all comments on the specified pull request.  Specifying a
+// ListComments lists all comments on the specified pull request. Specifying a
 // pull request number of 0 will return all comments on all pull requests for
 // the repository.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/comments/#list-comments-on-a-pull-request
-func (s *PullRequestsService) ListComments(owner string, repo string, number int, opt *PullRequestListCommentsOptions) ([]*PullRequestComment, *Response, error) {
+func (s *PullRequestsService) ListComments(ctx context.Context, owner string, repo string, number int, opt *PullRequestListCommentsOptions) ([]*PullRequestComment, *Response, error) {
 	var u string
 	if number == 0 {
 		u = fmt.Sprintf("repos/%v/%v/pulls/comments", owner, repo)
@@ -74,19 +75,19 @@ func (s *PullRequestsService) ListComments(owner string, repo string, number int
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	comments := new([]*PullRequestComment)
-	resp, err := s.client.Do(req, comments)
+	var comments []*PullRequestComment
+	resp, err := s.client.Do(ctx, req, &comments)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *comments, resp, err
+	return comments, resp, nil
 }
 
 // GetComment fetches the specified pull request comment.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/comments/#get-a-single-comment
-func (s *PullRequestsService) GetComment(owner string, repo string, number int) (*PullRequestComment, *Response, error) {
+func (s *PullRequestsService) GetComment(ctx context.Context, owner string, repo string, number int) (*PullRequestComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/comments/%d", owner, repo, number)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -97,18 +98,18 @@ func (s *PullRequestsService) GetComment(owner string, repo string, number int)
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	comment := new(PullRequestComment)
-	resp, err := s.client.Do(req, comment)
+	resp, err := s.client.Do(ctx, req, comment)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return comment, resp, err
+	return comment, resp, nil
 }
 
 // CreateComment creates a new comment on the specified pull request.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/comments/#create-a-comment
-func (s *PullRequestsService) CreateComment(owner string, repo string, number int, comment *PullRequestComment) (*PullRequestComment, *Response, error) {
+func (s *PullRequestsService) CreateComment(ctx context.Context, owner string, repo string, number int, comment *PullRequestComment) (*PullRequestComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/%d/comments", owner, repo, number)
 	req, err := s.client.NewRequest("POST", u, comment)
 	if err != nil {
@@ -116,18 +117,18 @@ func (s *PullRequestsService) CreateComment(owner string, repo string, number in
 	}
 
 	c := new(PullRequestComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // EditComment updates a pull request comment.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/comments/#edit-a-comment
-func (s *PullRequestsService) EditComment(owner string, repo string, number int, comment *PullRequestComment) (*PullRequestComment, *Response, error) {
+func (s *PullRequestsService) EditComment(ctx context.Context, owner string, repo string, number int, comment *PullRequestComment) (*PullRequestComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/comments/%d", owner, repo, number)
 	req, err := s.client.NewRequest("PATCH", u, comment)
 	if err != nil {
@@ -135,22 +136,22 @@ func (s *PullRequestsService) EditComment(owner string, repo string, number int,
 	}
 
 	c := new(PullRequestComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // DeleteComment deletes a pull request comment.
 //
 // GitHub API docs: https://developer.github.com/v3/pulls/comments/#delete-a-comment
-func (s *PullRequestsService) DeleteComment(owner string, repo string, number int) (*Response, error) {
+func (s *PullRequestsService) DeleteComment(ctx context.Context, owner string, repo string, number int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/comments/%d", owner, repo, number)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/pulls_reviewers.go

@@ -0,0 +1,84 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// RequestReviewers creates a review request for the provided GitHub users for the specified pull request.
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/review_requests/#create-a-review-request
+func (s *PullRequestsService) RequestReviewers(ctx context.Context, owner, repo string, number int, logins []string) (*PullRequest, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, number)
+
+	reviewers := struct {
+		Reviewers []string `json:"reviewers,omitempty"`
+	}{
+		Reviewers: logins,
+	}
+	req, err := s.client.NewRequest("POST", u, &reviewers)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	r := new(PullRequest)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// ListReviewers lists users whose reviews have been requested on the specified pull request.
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/review_requests/#list-review-requests
+func (s *PullRequestsService) ListReviewers(ctx context.Context, owner, repo string, number int) ([]*User, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/requested_reviewers", owner, repo, number)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	var users []*User
+	resp, err := s.client.Do(ctx, req, &users)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return users, resp, nil
+}
+
+// RemoveReviewers removes the review request for the provided GitHub users for the specified pull request.
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/review_requests/#delete-a-review-request
+func (s *PullRequestsService) RemoveReviewers(ctx context.Context, owner, repo string, number int, logins []string) (*Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, number)
+
+	reviewers := struct {
+		Reviewers []string `json:"reviewers,omitempty"`
+	}{
+		Reviewers: logins,
+	}
+	req, err := s.client.NewRequest("DELETE", u, &reviewers)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	return s.client.Do(ctx, req, reviewers)
+}

vendor/github.com/google/go-github/github/pulls_reviews.go

@@ -5,15 +5,244 @@
 
 package github
 
-import "time"
+import (
+	"context"
+	"fmt"
+	"time"
+)
 
 // PullRequestReview represents a review of a pull request.
 type PullRequestReview struct {
-	ID          *int       `json:"id,omitempty"`
-	User        *User      `json:"user,omitempty"`
-	Body        *string    `json:"body,omitempty"`
-	SubmittedAt *time.Time `json:"submitted_at,omitempty"`
-
-	// State can be "approved", "rejected", or "commented".
-	State *string `json:"state,omitempty"`
+	ID             *int       `json:"id,omitempty"`
+	User           *User      `json:"user,omitempty"`
+	Body           *string    `json:"body,omitempty"`
+	SubmittedAt    *time.Time `json:"submitted_at,omitempty"`
+	CommitID       *string    `json:"commit_id,omitempty"`
+	HTMLURL        *string    `json:"html_url,omitempty"`
+	PullRequestURL *string    `json:"pull_request_url,omitempty"`
+	State          *string    `json:"state,omitempty"`
+}
+
+func (p PullRequestReview) String() string {
+	return Stringify(p)
+}
+
+// DraftReviewComment represents a comment part of the review.
+type DraftReviewComment struct {
+	Path     *string `json:"path,omitempty"`
+	Position *int    `json:"position,omitempty"`
+	Body     *string `json:"body,omitempty"`
+}
+
+func (c DraftReviewComment) String() string {
+	return Stringify(c)
+}
+
+// PullRequestReviewRequest represents a request to create a review.
+type PullRequestReviewRequest struct {
+	Body     *string               `json:"body,omitempty"`
+	Event    *string               `json:"event,omitempty"`
+	Comments []*DraftReviewComment `json:"comments,omitempty"`
+}
+
+func (r PullRequestReviewRequest) String() string {
+	return Stringify(r)
+}
+
+// PullRequestReviewDismissalRequest represents a request to dismiss a review.
+type PullRequestReviewDismissalRequest struct {
+	Message *string `json:"message,omitempty"`
+}
+
+func (r PullRequestReviewDismissalRequest) String() string {
+	return Stringify(r)
+}
+
+// ListReviews lists all reviews on the specified pull request.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#list-reviews-on-a-pull-request
+func (s *PullRequestsService) ListReviews(ctx context.Context, owner, repo string, number int) ([]*PullRequestReview, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews", owner, repo, number)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	var reviews []*PullRequestReview
+	resp, err := s.client.Do(ctx, req, &reviews)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return reviews, resp, nil
+}
+
+// GetReview fetches the specified pull request review.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#get-a-single-review
+func (s *PullRequestsService) GetReview(ctx context.Context, owner, repo string, number, reviewID int) (*PullRequestReview, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews/%d", owner, repo, number, reviewID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	review := new(PullRequestReview)
+	resp, err := s.client.Do(ctx, req, review)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return review, resp, nil
+}
+
+// DeletePendingReview deletes the specified pull request pending review.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#delete-a-pending-review
+func (s *PullRequestsService) DeletePendingReview(ctx context.Context, owner, repo string, number, reviewID int) (*PullRequestReview, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews/%d", owner, repo, number, reviewID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	review := new(PullRequestReview)
+	resp, err := s.client.Do(ctx, req, review)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return review, resp, nil
+}
+
+// ListReviewComments lists all the comments for the specified review.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#get-a-single-reviews-comments
+func (s *PullRequestsService) ListReviewComments(ctx context.Context, owner, repo string, number, reviewID int) ([]*PullRequestComment, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews/%d/comments", owner, repo, number, reviewID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	var comments []*PullRequestComment
+	resp, err := s.client.Do(ctx, req, &comments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return comments, resp, nil
+}
+
+// CreateReview creates a new review on the specified pull request.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#create-a-pull-request-review
+func (s *PullRequestsService) CreateReview(ctx context.Context, owner, repo string, number int, review *PullRequestReviewRequest) (*PullRequestReview, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews", owner, repo, number)
+
+	req, err := s.client.NewRequest("POST", u, review)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	r := new(PullRequestReview)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// SubmitReview submits a specified review on the specified pull request.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#submit-a-pull-request-review
+func (s *PullRequestsService) SubmitReview(ctx context.Context, owner, repo string, number, reviewID int, review *PullRequestReviewRequest) (*PullRequestReview, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews/%d/events", owner, repo, number, reviewID)
+
+	req, err := s.client.NewRequest("POST", u, review)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	r := new(PullRequestReview)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// DismissReview dismisses a specified review on the specified pull request.
+//
+// TODO: Follow up with GitHub support about an issue with this method's
+// returned error format and remove this comment once it's fixed.
+// Read more about it here - https://github.com/google/go-github/issues/540
+//
+// GitHub API docs: https://developer.github.com/v3/pulls/reviews/#dismiss-a-pull-request-review
+func (s *PullRequestsService) DismissReview(ctx context.Context, owner, repo string, number, reviewID int, review *PullRequestReviewDismissalRequest) (*PullRequestReview, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/pulls/%d/reviews/%d/dismissals", owner, repo, number, reviewID)
+
+	req, err := s.client.NewRequest("PUT", u, review)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypePullRequestReviewsPreview)
+
+	r := new(PullRequestReview)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
 }

vendor/github.com/google/go-github/github/reactions.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // ReactionsService provides access to the reactions-related functions in the
 // GitHub API.
@@ -43,7 +46,7 @@ func (r Reaction) String() string {
 // ListCommentReactions lists the reactions for a commit comment.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#list-reactions-for-a-commit-comment
-func (s *ReactionsService) ListCommentReactions(owner, repo string, id int, opt *ListOptions) ([]*Reaction, *Response, error) {
+func (s *ReactionsService) ListCommentReactions(ctx context.Context, owner, repo string, id int, opt *ListOptions) ([]*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/comments/%v/reactions", owner, repo, id)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -59,7 +62,7 @@ func (s *ReactionsService) ListCommentReactions(owner, repo string, id int, opt
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	var m []*Reaction
-	resp, err := s.client.Do(req, &m)
+	resp, err := s.client.Do(ctx, req, &m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -72,7 +75,7 @@ func (s *ReactionsService) ListCommentReactions(owner, repo string, id int, opt
 // previously created reaction will be returned with Status: 200 OK.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#create-reaction-for-a-commit-comment
-func (s ReactionsService) CreateCommentReaction(owner, repo string, id int, content string) (*Reaction, *Response, error) {
+func (s ReactionsService) CreateCommentReaction(ctx context.Context, owner, repo string, id int, content string) (*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/comments/%v/reactions", owner, repo, id)
 
 	body := &Reaction{Content: String(content)}
@@ -85,7 +88,7 @@ func (s ReactionsService) CreateCommentReaction(owner, repo string, id int, cont
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	m := &Reaction{}
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -96,7 +99,7 @@ func (s ReactionsService) CreateCommentReaction(owner, repo string, id int, cont
 // ListIssueReactions lists the reactions for an issue.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#list-reactions-for-an-issue
-func (s *ReactionsService) ListIssueReactions(owner, repo string, number int, opt *ListOptions) ([]*Reaction, *Response, error) {
+func (s *ReactionsService) ListIssueReactions(ctx context.Context, owner, repo string, number int, opt *ListOptions) ([]*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%v/reactions", owner, repo, number)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -112,7 +115,7 @@ func (s *ReactionsService) ListIssueReactions(owner, repo string, number int, op
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	var m []*Reaction
-	resp, err := s.client.Do(req, &m)
+	resp, err := s.client.Do(ctx, req, &m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -125,7 +128,7 @@ func (s *ReactionsService) ListIssueReactions(owner, repo string, number int, op
 // previously created reaction will be returned with Status: 200 OK.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#create-reaction-for-an-issue
-func (s ReactionsService) CreateIssueReaction(owner, repo string, number int, content string) (*Reaction, *Response, error) {
+func (s ReactionsService) CreateIssueReaction(ctx context.Context, owner, repo string, number int, content string) (*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/%v/reactions", owner, repo, number)
 
 	body := &Reaction{Content: String(content)}
@@ -138,7 +141,7 @@ func (s ReactionsService) CreateIssueReaction(owner, repo string, number int, co
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	m := &Reaction{}
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -149,7 +152,7 @@ func (s ReactionsService) CreateIssueReaction(owner, repo string, number int, co
 // ListIssueCommentReactions lists the reactions for an issue comment.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment
-func (s *ReactionsService) ListIssueCommentReactions(owner, repo string, id int, opt *ListOptions) ([]*Reaction, *Response, error) {
+func (s *ReactionsService) ListIssueCommentReactions(ctx context.Context, owner, repo string, id int, opt *ListOptions) ([]*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/comments/%v/reactions", owner, repo, id)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -165,7 +168,7 @@ func (s *ReactionsService) ListIssueCommentReactions(owner, repo string, id int,
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	var m []*Reaction
-	resp, err := s.client.Do(req, &m)
+	resp, err := s.client.Do(ctx, req, &m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -178,7 +181,7 @@ func (s *ReactionsService) ListIssueCommentReactions(owner, repo string, id int,
 // previously created reaction will be returned with Status: 200 OK.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment
-func (s ReactionsService) CreateIssueCommentReaction(owner, repo string, id int, content string) (*Reaction, *Response, error) {
+func (s ReactionsService) CreateIssueCommentReaction(ctx context.Context, owner, repo string, id int, content string) (*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/issues/comments/%v/reactions", owner, repo, id)
 
 	body := &Reaction{Content: String(content)}
@@ -191,7 +194,7 @@ func (s ReactionsService) CreateIssueCommentReaction(owner, repo string, id int,
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	m := &Reaction{}
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -202,7 +205,7 @@ func (s ReactionsService) CreateIssueCommentReaction(owner, repo string, id int,
 // ListPullRequestCommentReactions lists the reactions for a pull request review comment.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment
-func (s *ReactionsService) ListPullRequestCommentReactions(owner, repo string, id int, opt *ListOptions) ([]*Reaction, *Response, error) {
+func (s *ReactionsService) ListPullRequestCommentReactions(ctx context.Context, owner, repo string, id int, opt *ListOptions) ([]*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/comments/%v/reactions", owner, repo, id)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -218,7 +221,7 @@ func (s *ReactionsService) ListPullRequestCommentReactions(owner, repo string, i
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	var m []*Reaction
-	resp, err := s.client.Do(req, &m)
+	resp, err := s.client.Do(ctx, req, &m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -231,7 +234,7 @@ func (s *ReactionsService) ListPullRequestCommentReactions(owner, repo string, i
 // previously created reaction will be returned with Status: 200 OK.
 //
 // GitHub API docs: https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment
-func (s ReactionsService) CreatePullRequestCommentReaction(owner, repo string, id int, content string) (*Reaction, *Response, error) {
+func (s ReactionsService) CreatePullRequestCommentReaction(ctx context.Context, owner, repo string, id int, content string) (*Reaction, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pulls/comments/%v/reactions", owner, repo, id)
 
 	body := &Reaction{Content: String(content)}
@@ -244,7 +247,7 @@ func (s ReactionsService) CreatePullRequestCommentReaction(owner, repo string, i
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	m := &Reaction{}
-	resp, err := s.client.Do(req, m)
+	resp, err := s.client.Do(ctx, req, m)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -255,7 +258,7 @@ func (s ReactionsService) CreatePullRequestCommentReaction(owner, repo string, i
 // DeleteReaction deletes a reaction.
 //
 // GitHub API docs: https://developer.github.com/v3/reaction/reactions/#delete-a-reaction-archive
-func (s *ReactionsService) DeleteReaction(id int) (*Response, error) {
+func (s *ReactionsService) DeleteReaction(ctx context.Context, id int) (*Response, error) {
 	u := fmt.Sprintf("reactions/%v", id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -266,5 +269,5 @@ func (s *ReactionsService) DeleteReaction(id int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/repos.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"strings"
 )
@@ -13,7 +14,7 @@ import (
 // RepositoriesService handles communication with the repository related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/
+// GitHub API docs: https://developer.github.com/v3/repos/
 type RepositoriesService service
 
 // Repository represents a GitHub repository.
@@ -151,11 +152,11 @@ type RepositoryListOptions struct {
 	ListOptions
 }
 
-// List the repositories for a user.  Passing the empty string will list
+// List the repositories for a user. Passing the empty string will list
 // repositories for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#list-user-repositories
-func (s *RepositoriesService) List(user string, opt *RepositoryListOptions) ([]*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#list-user-repositories
+func (s *RepositoriesService) List(ctx context.Context, user string, opt *RepositoryListOptions) ([]*Repository, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/repos", user)
@@ -175,20 +176,20 @@ func (s *RepositoriesService) List(user string, opt *RepositoryListOptions) ([]*
 	// TODO: remove custom Accept header when license support fully launches
 	req.Header.Set("Accept", mediaTypeLicensesPreview)
 
-	repos := new([]*Repository)
-	resp, err := s.client.Do(req, repos)
+	var repos []*Repository
+	resp, err := s.client.Do(ctx, req, &repos)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *repos, resp, err
+	return repos, resp, nil
 }
 
 // RepositoryListByOrgOptions specifies the optional parameters to the
 // RepositoriesService.ListByOrg method.
 type RepositoryListByOrgOptions struct {
-	// Type of repositories to list.  Possible values are: all, public, private,
-	// forks, sources, member.  Default is "all".
+	// Type of repositories to list. Possible values are: all, public, private,
+	// forks, sources, member. Default is "all".
 	Type string `url:"type,omitempty"`
 
 	ListOptions
@@ -196,8 +197,8 @@ type RepositoryListByOrgOptions struct {
 
 // ListByOrg lists the repositories for an organization.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#list-organization-repositories
-func (s *RepositoriesService) ListByOrg(org string, opt *RepositoryListByOrgOptions) ([]*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#list-organization-repositories
+func (s *RepositoriesService) ListByOrg(ctx context.Context, org string, opt *RepositoryListByOrgOptions) ([]*Repository, *Response, error) {
 	u := fmt.Sprintf("orgs/%v/repos", org)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -212,13 +213,13 @@ func (s *RepositoriesService) ListByOrg(org string, opt *RepositoryListByOrgOpti
 	// TODO: remove custom Accept header when license support fully launches
 	req.Header.Set("Accept", mediaTypeLicensesPreview)
 
-	repos := new([]*Repository)
-	resp, err := s.client.Do(req, repos)
+	var repos []*Repository
+	resp, err := s.client.Do(ctx, req, &repos)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *repos, resp, err
+	return repos, resp, nil
 }
 
 // RepositoryListAllOptions specifies the optional parameters to the
@@ -232,8 +233,8 @@ type RepositoryListAllOptions struct {
 
 // ListAll lists all GitHub repositories in the order that they were created.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#list-all-public-repositories
-func (s *RepositoriesService) ListAll(opt *RepositoryListAllOptions) ([]*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#list-all-public-repositories
+func (s *RepositoriesService) ListAll(ctx context.Context, opt *RepositoryListAllOptions) ([]*Repository, *Response, error) {
 	u, err := addOptions("repositories", opt)
 	if err != nil {
 		return nil, nil, err
@@ -244,21 +245,21 @@ func (s *RepositoriesService) ListAll(opt *RepositoryListAllOptions) ([]*Reposit
 		return nil, nil, err
 	}
 
-	repos := new([]*Repository)
-	resp, err := s.client.Do(req, repos)
+	var repos []*Repository
+	resp, err := s.client.Do(ctx, req, &repos)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *repos, resp, err
+	return repos, resp, nil
 }
 
-// Create a new repository.  If an organization is specified, the new
-// repository will be created under that org.  If the empty string is
+// Create a new repository. If an organization is specified, the new
+// repository will be created under that org. If the empty string is
 // specified, it will be created for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#create
-func (s *RepositoriesService) Create(org string, repo *Repository) (*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#create
+func (s *RepositoriesService) Create(ctx context.Context, org string, repo *Repository) (*Repository, *Response, error) {
 	var u string
 	if org != "" {
 		u = fmt.Sprintf("orgs/%v/repos", org)
@@ -272,18 +273,18 @@ func (s *RepositoriesService) Create(org string, repo *Repository) (*Repository,
 	}
 
 	r := new(Repository)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r, resp, err
+	return r, resp, nil
 }
 
 // Get fetches a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#get
-func (s *RepositoriesService) Get(owner, repo string) (*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#get
+func (s *RepositoriesService) Get(ctx context.Context, owner, repo string) (*Repository, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -296,18 +297,18 @@ func (s *RepositoriesService) Get(owner, repo string) (*Repository, *Response, e
 	req.Header.Set("Accept", strings.Join(acceptHeaders, ", "))
 
 	repository := new(Repository)
-	resp, err := s.client.Do(req, repository)
+	resp, err := s.client.Do(ctx, req, repository)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return repository, resp, err
+	return repository, resp, nil
 }
 
 // GetByID fetches a repository.
 //
 // Note: GetByID uses the undocumented GitHub API endpoint /repositories/:id.
-func (s *RepositoriesService) GetByID(id int) (*Repository, *Response, error) {
+func (s *RepositoriesService) GetByID(ctx context.Context, id int) (*Repository, *Response, error) {
 	u := fmt.Sprintf("repositories/%d", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -319,18 +320,18 @@ func (s *RepositoriesService) GetByID(id int) (*Repository, *Response, error) {
 	req.Header.Set("Accept", mediaTypeLicensesPreview)
 
 	repository := new(Repository)
-	resp, err := s.client.Do(req, repository)
+	resp, err := s.client.Do(ctx, req, repository)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return repository, resp, err
+	return repository, resp, nil
 }
 
 // Edit updates a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#edit
-func (s *RepositoriesService) Edit(owner, repo string, repository *Repository) (*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#edit
+func (s *RepositoriesService) Edit(ctx context.Context, owner, repo string, repository *Repository) (*Repository, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v", owner, repo)
 	req, err := s.client.NewRequest("PATCH", u, repository)
 	if err != nil {
@@ -338,28 +339,28 @@ func (s *RepositoriesService) Edit(owner, repo string, repository *Repository) (
 	}
 
 	// TODO: Remove this preview header after API is fully vetted.
-	req.Header.Add("Accept", mediaTypeSquashPreview)
+	req.Header.Set("Accept", mediaTypeSquashPreview)
 
 	r := new(Repository)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r, resp, err
+	return r, resp, nil
 }
 
 // Delete a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/#delete-a-repository
-func (s *RepositoriesService) Delete(owner, repo string) (*Response, error) {
+func (s *RepositoriesService) Delete(ctx context.Context, owner, repo string) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v", owner, repo)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Contributor represents a repository contributor
@@ -395,8 +396,8 @@ type ListContributorsOptions struct {
 
 // ListContributors lists contributors for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#list-contributors
-func (s *RepositoriesService) ListContributors(owner string, repository string, opt *ListContributorsOptions) ([]*Contributor, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#list-contributors
+func (s *RepositoriesService) ListContributors(ctx context.Context, owner string, repository string, opt *ListContributorsOptions) ([]*Contributor, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/contributors", owner, repository)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -408,13 +409,13 @@ func (s *RepositoriesService) ListContributors(owner string, repository string,
 		return nil, nil, err
 	}
 
-	contributor := new([]*Contributor)
-	resp, err := s.client.Do(req, contributor)
+	var contributor []*Contributor
+	resp, err := s.client.Do(ctx, req, &contributor)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return *contributor, resp, err
+	return contributor, resp, nil
 }
 
 // ListLanguages lists languages for the specified repository. The returned map
@@ -426,8 +427,8 @@ func (s *RepositoriesService) ListContributors(owner string, repository string,
 //       "Python": 7769
 //     }
 //
-// GitHub API Docs: http://developer.github.com/v3/repos/#list-languages
-func (s *RepositoriesService) ListLanguages(owner string, repo string) (map[string]int, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#list-languages
+func (s *RepositoriesService) ListLanguages(ctx context.Context, owner string, repo string) (map[string]int, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/languages", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -435,18 +436,18 @@ func (s *RepositoriesService) ListLanguages(owner string, repo string) (map[stri
 	}
 
 	languages := make(map[string]int)
-	resp, err := s.client.Do(req, &languages)
+	resp, err := s.client.Do(ctx, req, &languages)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return languages, resp, err
+	return languages, resp, nil
 }
 
 // ListTeams lists the teams for the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/#list-teams
-func (s *RepositoriesService) ListTeams(owner string, repo string, opt *ListOptions) ([]*Team, *Response, error) {
+func (s *RepositoriesService) ListTeams(ctx context.Context, owner string, repo string, opt *ListOptions) ([]*Team, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/teams", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -458,13 +459,13 @@ func (s *RepositoriesService) ListTeams(owner string, repo string, opt *ListOpti
 		return nil, nil, err
 	}
 
-	teams := new([]*Team)
-	resp, err := s.client.Do(req, teams)
+	var teams []*Team
+	resp, err := s.client.Do(ctx, req, &teams)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *teams, resp, err
+	return teams, resp, nil
 }
 
 // RepositoryTag represents a repository tag.
@@ -478,7 +479,7 @@ type RepositoryTag struct {
 // ListTags lists tags for the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/#list-tags
-func (s *RepositoriesService) ListTags(owner string, repo string, opt *ListOptions) ([]*RepositoryTag, *Response, error) {
+func (s *RepositoriesService) ListTags(ctx context.Context, owner string, repo string, opt *ListOptions) ([]*RepositoryTag, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/tags", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -490,13 +491,13 @@ func (s *RepositoriesService) ListTags(owner string, repo string, opt *ListOptio
 		return nil, nil, err
 	}
 
-	tags := new([]*RepositoryTag)
-	resp, err := s.client.Do(req, tags)
+	var tags []*RepositoryTag
+	resp, err := s.client.Do(ctx, req, &tags)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *tags, resp, err
+	return tags, resp, nil
 }
 
 // Branch represents a repository branch
@@ -508,34 +509,42 @@ type Branch struct {
 
 // Protection represents a repository branch's protection.
 type Protection struct {
-	RequiredStatusChecks *RequiredStatusChecks `json:"required_status_checks"`
-	Restrictions         *BranchRestrictions   `json:"restrictions"`
+	RequiredStatusChecks       *RequiredStatusChecks       `json:"required_status_checks"`
+	RequiredPullRequestReviews *RequiredPullRequestReviews `json:"required_pull_request_reviews"`
+	Restrictions               *BranchRestrictions         `json:"restrictions"`
 }
 
 // ProtectionRequest represents a request to create/edit a branch's protection.
 type ProtectionRequest struct {
-	RequiredStatusChecks *RequiredStatusChecks      `json:"required_status_checks"`
-	Restrictions         *BranchRestrictionsRequest `json:"restrictions"`
+	RequiredStatusChecks       *RequiredStatusChecks       `json:"required_status_checks"`
+	RequiredPullRequestReviews *RequiredPullRequestReviews `json:"required_pull_request_reviews"`
+	Restrictions               *BranchRestrictionsRequest  `json:"restrictions"`
 }
 
 // RequiredStatusChecks represents the protection status of a individual branch.
 type RequiredStatusChecks struct {
-	// Enforce required status checks for repository administrators.
-	IncludeAdmins *bool `json:"include_admins,omitempty"`
-	// Require branches to be up to date before merging.
-	Strict *bool `json:"strict,omitempty"`
+	// Enforce required status checks for repository administrators. (Required.)
+	IncludeAdmins bool `json:"include_admins"`
+	// Require branches to be up to date before merging. (Required.)
+	Strict bool `json:"strict"`
 	// The list of status checks to require in order to merge into this
-	// branch.
-	Contexts *[]string `json:"contexts,omitempty"`
+	// branch. (Required; use []string{} instead of nil for empty list.)
+	Contexts []string `json:"contexts"`
+}
+
+// RequiredPullRequestReviews represents the protection configuration for pull requests.
+type RequiredPullRequestReviews struct {
+	// Enforce pull request reviews for repository administrators. (Required.)
+	IncludeAdmins bool `json:"include_admins"`
 }
 
 // BranchRestrictions represents the restriction that only certain users or
 // teams may push to a branch.
 type BranchRestrictions struct {
 	// The list of user logins with push access.
-	Users []*User `json:"users,omitempty"`
+	Users []*User `json:"users"`
 	// The list of team slugs with push access.
-	Teams []*Team `json:"teams,omitempty"`
+	Teams []*Team `json:"teams"`
 }
 
 // BranchRestrictionsRequest represents the request to create/edit the
@@ -543,16 +552,16 @@ type BranchRestrictions struct {
 // separate from BranchRestrictions above because the request structure is
 // different from the response structure.
 type BranchRestrictionsRequest struct {
-	// The list of user logins with push access.
-	Users *[]string `json:"users,omitempty"`
-	// The list of team slugs with push access.
-	Teams *[]string `json:"teams,omitempty"`
+	// The list of user logins with push access. (Required; use []string{} instead of nil for empty list.)
+	Users []string `json:"users"`
+	// The list of team slugs with push access. (Required; use []string{} instead of nil for empty list.)
+	Teams []string `json:"teams"`
 }
 
 // ListBranches lists branches for the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/#list-branches
-func (s *RepositoriesService) ListBranches(owner string, repo string, opt *ListOptions) ([]*Branch, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/#list-branches
+func (s *RepositoriesService) ListBranches(ctx context.Context, owner string, repo string, opt *ListOptions) ([]*Branch, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/branches", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -567,19 +576,19 @@ func (s *RepositoriesService) ListBranches(owner string, repo string, opt *ListO
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
 
-	branches := new([]*Branch)
-	resp, err := s.client.Do(req, branches)
+	var branches []*Branch
+	resp, err := s.client.Do(ctx, req, &branches)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *branches, resp, err
+	return branches, resp, nil
 }
 
 // GetBranch gets the specified branch for a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/#get-branch
-func (s *RepositoriesService) GetBranch(owner, repo, branch string) (*Branch, *Response, error) {
+func (s *RepositoriesService) GetBranch(ctx context.Context, owner, repo, branch string) (*Branch, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/branches/%v", owner, repo, branch)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -590,18 +599,18 @@ func (s *RepositoriesService) GetBranch(owner, repo, branch string) (*Branch, *R
 	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
 
 	b := new(Branch)
-	resp, err := s.client.Do(req, b)
+	resp, err := s.client.Do(ctx, req, b)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return b, resp, err
+	return b, resp, nil
 }
 
 // GetBranchProtection gets the protection of a given branch.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/branches/#get-branch-protection
-func (s *RepositoriesService) GetBranchProtection(owner, repo, branch string) (*Protection, *Response, error) {
+func (s *RepositoriesService) GetBranchProtection(ctx context.Context, owner, repo, branch string) (*Protection, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/branches/%v/protection", owner, repo, branch)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -612,18 +621,61 @@ func (s *RepositoriesService) GetBranchProtection(owner, repo, branch string) (*
 	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
 
 	p := new(Protection)
-	resp, err := s.client.Do(req, p)
+	resp, err := s.client.Do(ctx, req, p)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return p, resp, err
+	return p, resp, nil
+}
+
+// GetRequiredStatusChecks gets the required status checks for a given protected branch.
+//
+// GitHub API docs: https://developer.github.com/v3/repos/branches/#get-required-status-checks-of-protected-branch
+func (s *RepositoriesService) GetRequiredStatusChecks(ctx context.Context, owner, repo, branch string) (*RequiredStatusChecks, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/branches/%v/protection/required_status_checks", owner, repo, branch)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
+
+	p := new(RequiredStatusChecks)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}
+
+// ListRequiredStatusChecksContexts lists the required status checks contexts for a given protected branch.
+//
+// GitHub API docs: https://developer.github.com/v3/repos/branches/#list-required-status-checks-contexts-of-protected-branch
+func (s *RepositoriesService) ListRequiredStatusChecksContexts(ctx context.Context, owner, repo, branch string) (contexts []string, resp *Response, err error) {
+	u := fmt.Sprintf("repos/%v/%v/branches/%v/protection/required_status_checks/contexts", owner, repo, branch)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
+
+	resp, err = s.client.Do(ctx, req, &contexts)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return contexts, resp, nil
 }
 
 // UpdateBranchProtection updates the protection of a given branch.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/branches/#update-branch-protection
-func (s *RepositoriesService) UpdateBranchProtection(owner, repo, branch string, preq *ProtectionRequest) (*Protection, *Response, error) {
+func (s *RepositoriesService) UpdateBranchProtection(ctx context.Context, owner, repo, branch string, preq *ProtectionRequest) (*Protection, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/branches/%v/protection", owner, repo, branch)
 	req, err := s.client.NewRequest("PUT", u, preq)
 	if err != nil {
@@ -634,18 +686,18 @@ func (s *RepositoriesService) UpdateBranchProtection(owner, repo, branch string,
 	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
 
 	p := new(Protection)
-	resp, err := s.client.Do(req, p)
+	resp, err := s.client.Do(ctx, req, p)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return p, resp, err
+	return p, resp, nil
 }
 
 // RemoveBranchProtection removes the protection of a given branch.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/branches/#remove-branch-protection
-func (s *RepositoriesService) RemoveBranchProtection(owner, repo, branch string) (*Response, error) {
+func (s *RepositoriesService) RemoveBranchProtection(ctx context.Context, owner, repo, branch string) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/branches/%v/protection", owner, repo, branch)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -655,13 +707,13 @@ func (s *RepositoriesService) RemoveBranchProtection(owner, repo, branch string)
 	// TODO: remove custom Accept header when this API fully launches
 	req.Header.Set("Accept", mediaTypeProtectedBranchesPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // License gets the contents of a repository's license if one is detected.
 //
 // GitHub API docs: https://developer.github.com/v3/licenses/#get-the-contents-of-a-repositorys-license
-func (s *RepositoriesService) License(owner, repo string) (*RepositoryLicense, *Response, error) {
+func (s *RepositoriesService) License(ctx context.Context, owner, repo string) (*RepositoryLicense, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/license", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -669,10 +721,10 @@ func (s *RepositoriesService) License(owner, repo string) (*RepositoryLicense, *
 	}
 
 	r := &RepositoryLicense{}
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return r, resp, err
+	return r, resp, nil
 }

vendor/github.com/google/go-github/github/repos_collaborators.go

@@ -5,12 +5,15 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
-// ListCollaborators lists the Github users that have access to the repository.
+// ListCollaborators lists the GitHub users that have access to the repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/collaborators/#list
-func (s *RepositoriesService) ListCollaborators(owner, repo string, opt *ListOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/collaborators/#list
+func (s *RepositoriesService) ListCollaborators(ctx context.Context, owner, repo string, opt *ListOptions) ([]*User, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/collaborators", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -22,33 +25,59 @@ func (s *RepositoriesService) ListCollaborators(owner, repo string, opt *ListOpt
 		return nil, nil, err
 	}
 
-	users := new([]*User)
-	resp, err := s.client.Do(req, users)
+	var users []*User
+	resp, err := s.client.Do(ctx, req, &users)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *users, resp, err
+	return users, resp, nil
 }
 
-// IsCollaborator checks whether the specified Github user has collaborator
+// IsCollaborator checks whether the specified GitHub user has collaborator
 // access to the given repo.
 // Note: This will return false if the user is not a collaborator OR the user
 // is not a GitHub user.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/collaborators/#get
-func (s *RepositoriesService) IsCollaborator(owner, repo, user string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/collaborators/#get
+func (s *RepositoriesService) IsCollaborator(ctx context.Context, owner, repo, user string) (bool, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/collaborators/%v", owner, repo, user)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return false, nil, err
 	}
 
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	isCollab, err := parseBoolResponse(err)
 	return isCollab, resp, err
 }
 
+// RepositoryPermissionLevel represents the permission level an organization
+// member has for a given repository.
+type RepositoryPermissionLevel struct {
+	// Possible values: "admin", "write", "read", "none"
+	Permission *string `json:"permission,omitempty"`
+
+	User *User `json:"user,omitempty"`
+}
+
+// GetPermissionLevel retrieves the specific permission level a collaborator has for a given repository.
+// GitHub API docs: https://developer.github.com/v3/repos/collaborators/#review-a-users-permission-level
+func (s *RepositoriesService) GetPermissionLevel(ctx context.Context, owner, repo, user string) (*RepositoryPermissionLevel, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/collaborators/%v/permission", owner, repo, user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	rpl := new(RepositoryPermissionLevel)
+	resp, err := s.client.Do(ctx, req, rpl)
+	if err != nil {
+		return nil, resp, err
+	}
+	return rpl, resp, nil
+}
+
 // RepositoryAddCollaboratorOptions specifies the optional parameters to the
 // RepositoriesService.AddCollaborator method.
 type RepositoryAddCollaboratorOptions struct {
@@ -58,14 +87,14 @@ type RepositoryAddCollaboratorOptions struct {
 	//     push - team members can pull and push, but not administer this repository
 	//     admin - team members can pull, push and administer this repository
 	//
-	// Default value is "push".  This option is only valid for organization-owned repositories.
+	// Default value is "push". This option is only valid for organization-owned repositories.
 	Permission string `json:"permission,omitempty"`
 }
 
-// AddCollaborator adds the specified Github user as collaborator to the given repo.
+// AddCollaborator adds the specified GitHub user as collaborator to the given repo.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/collaborators/#add-user-as-a-collaborator
-func (s *RepositoriesService) AddCollaborator(owner, repo, user string, opt *RepositoryAddCollaboratorOptions) (*Response, error) {
+func (s *RepositoriesService) AddCollaborator(ctx context.Context, owner, repo, user string, opt *RepositoryAddCollaboratorOptions) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/collaborators/%v", owner, repo, user)
 	req, err := s.client.NewRequest("PUT", u, opt)
 	if err != nil {
@@ -75,18 +104,18 @@ func (s *RepositoriesService) AddCollaborator(owner, repo, user string, opt *Rep
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
-// RemoveCollaborator removes the specified Github user as collaborator from the given repo.
+// RemoveCollaborator removes the specified GitHub user as collaborator from the given repo.
 // Note: Does not return error if a valid user that is not a collaborator is removed.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/collaborators/#remove-collaborator
-func (s *RepositoriesService) RemoveCollaborator(owner, repo, user string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/collaborators/#remove-collaborator
+func (s *RepositoriesService) RemoveCollaborator(ctx context.Context, owner, repo, user string) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/collaborators/%v", owner, repo, user)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/repos_comments.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -34,8 +35,8 @@ func (r RepositoryComment) String() string {
 
 // ListComments lists all the comments for the repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/comments/#list-commit-comments-for-a-repository
-func (s *RepositoriesService) ListComments(owner, repo string, opt *ListOptions) ([]*RepositoryComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/comments/#list-commit-comments-for-a-repository
+func (s *RepositoriesService) ListComments(ctx context.Context, owner, repo string, opt *ListOptions) ([]*RepositoryComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/comments", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -50,19 +51,19 @@ func (s *RepositoriesService) ListComments(owner, repo string, opt *ListOptions)
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	comments := new([]*RepositoryComment)
-	resp, err := s.client.Do(req, comments)
+	var comments []*RepositoryComment
+	resp, err := s.client.Do(ctx, req, &comments)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *comments, resp, err
+	return comments, resp, nil
 }
 
 // ListCommitComments lists all the comments for a given commit SHA.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/comments/#list-comments-for-a-single-commit
-func (s *RepositoriesService) ListCommitComments(owner, repo, sha string, opt *ListOptions) ([]*RepositoryComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/comments/#list-comments-for-a-single-commit
+func (s *RepositoriesService) ListCommitComments(ctx context.Context, owner, repo, sha string, opt *ListOptions) ([]*RepositoryComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits/%v/comments", owner, repo, sha)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -77,20 +78,20 @@ func (s *RepositoriesService) ListCommitComments(owner, repo, sha string, opt *L
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
-	comments := new([]*RepositoryComment)
-	resp, err := s.client.Do(req, comments)
+	var comments []*RepositoryComment
+	resp, err := s.client.Do(ctx, req, &comments)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *comments, resp, err
+	return comments, resp, nil
 }
 
 // CreateComment creates a comment for the given commit.
 // Note: GitHub allows for comments to be created for non-existing files and positions.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/comments/#create-a-commit-comment
-func (s *RepositoriesService) CreateComment(owner, repo, sha string, comment *RepositoryComment) (*RepositoryComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/comments/#create-a-commit-comment
+func (s *RepositoriesService) CreateComment(ctx context.Context, owner, repo, sha string, comment *RepositoryComment) (*RepositoryComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits/%v/comments", owner, repo, sha)
 	req, err := s.client.NewRequest("POST", u, comment)
 	if err != nil {
@@ -98,18 +99,18 @@ func (s *RepositoriesService) CreateComment(owner, repo, sha string, comment *Re
 	}
 
 	c := new(RepositoryComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // GetComment gets a single comment from a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/comments/#get-a-single-commit-comment
-func (s *RepositoriesService) GetComment(owner, repo string, id int) (*RepositoryComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/comments/#get-a-single-commit-comment
+func (s *RepositoriesService) GetComment(ctx context.Context, owner, repo string, id int) (*RepositoryComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/comments/%v", owner, repo, id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -120,18 +121,18 @@ func (s *RepositoriesService) GetComment(owner, repo string, id int) (*Repositor
 	req.Header.Set("Accept", mediaTypeReactionsPreview)
 
 	c := new(RepositoryComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // UpdateComment updates the body of a single comment.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/comments/#update-a-commit-comment
-func (s *RepositoriesService) UpdateComment(owner, repo string, id int, comment *RepositoryComment) (*RepositoryComment, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/comments/#update-a-commit-comment
+func (s *RepositoriesService) UpdateComment(ctx context.Context, owner, repo string, id int, comment *RepositoryComment) (*RepositoryComment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/comments/%v", owner, repo, id)
 	req, err := s.client.NewRequest("PATCH", u, comment)
 	if err != nil {
@@ -139,22 +140,22 @@ func (s *RepositoriesService) UpdateComment(owner, repo string, id int, comment
 	}
 
 	c := new(RepositoryComment)
-	resp, err := s.client.Do(req, c)
+	resp, err := s.client.Do(ctx, req, c)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return c, resp, err
+	return c, resp, nil
 }
 
 // DeleteComment deletes a single comment from a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/comments/#delete-a-commit-comment
-func (s *RepositoriesService) DeleteComment(owner, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/comments/#delete-a-commit-comment
+func (s *RepositoriesService) DeleteComment(ctx context.Context, owner, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/comments/%v", owner, repo, id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/repos_commits.go

@@ -7,6 +7,7 @@ package github
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"time"
 )
@@ -107,8 +108,8 @@ type CommitsListOptions struct {
 
 // ListCommits lists the commits of a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/commits/#list
-func (s *RepositoriesService) ListCommits(owner, repo string, opt *CommitsListOptions) ([]*RepositoryCommit, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/commits/#list
+func (s *RepositoriesService) ListCommits(ctx context.Context, owner, repo string, opt *CommitsListOptions) ([]*RepositoryCommit, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -120,21 +121,21 @@ func (s *RepositoriesService) ListCommits(owner, repo string, opt *CommitsListOp
 		return nil, nil, err
 	}
 
-	commits := new([]*RepositoryCommit)
-	resp, err := s.client.Do(req, commits)
+	var commits []*RepositoryCommit
+	resp, err := s.client.Do(ctx, req, &commits)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *commits, resp, err
+	return commits, resp, nil
 }
 
 // GetCommit fetches the specified commit, including all details about it.
 // todo: support media formats - https://github.com/google/go-github/issues/6
 //
-// GitHub API docs: http://developer.github.com/v3/repos/commits/#get-a-single-commit
-// See also: http://developer.github.com//v3/git/commits/#get-a-single-commit provides the same functionality
-func (s *RepositoriesService) GetCommit(owner, repo, sha string) (*RepositoryCommit, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/commits/#get-a-single-commit
+// See also: https://developer.github.com//v3/git/commits/#get-a-single-commit provides the same functionality
+func (s *RepositoriesService) GetCommit(ctx context.Context, owner, repo, sha string) (*RepositoryCommit, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits/%v", owner, repo, sha)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -146,19 +147,19 @@ func (s *RepositoriesService) GetCommit(owner, repo, sha string) (*RepositoryCom
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
 	commit := new(RepositoryCommit)
-	resp, err := s.client.Do(req, commit)
+	resp, err := s.client.Do(ctx, req, commit)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return commit, resp, err
+	return commit, resp, nil
 }
 
-// GetCommitSHA1 gets the SHA-1 of a commit reference.  If a last-known SHA1 is
+// GetCommitSHA1 gets the SHA-1 of a commit reference. If a last-known SHA1 is
 // supplied and no new commits have occurred, a 304 Unmodified response is returned.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/commits/#get-the-sha-1-of-a-commit-reference
-func (s *RepositoriesService) GetCommitSHA1(owner, repo, ref, lastSHA string) (string, *Response, error) {
+func (s *RepositoriesService) GetCommitSHA1(ctx context.Context, owner, repo, ref, lastSHA string) (string, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits/%v", owner, repo, ref)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -172,19 +173,19 @@ func (s *RepositoriesService) GetCommitSHA1(owner, repo, ref, lastSHA string) (s
 	req.Header.Set("Accept", mediaTypeV3SHA)
 
 	var buf bytes.Buffer
-	resp, err := s.client.Do(req, &buf)
+	resp, err := s.client.Do(ctx, req, &buf)
 	if err != nil {
 		return "", resp, err
 	}
 
-	return buf.String(), resp, err
+	return buf.String(), resp, nil
 }
 
 // CompareCommits compares a range of commits with each other.
 // todo: support media formats - https://github.com/google/go-github/issues/6
 //
-// GitHub API docs: http://developer.github.com/v3/repos/commits/index.html#compare-two-commits
-func (s *RepositoriesService) CompareCommits(owner, repo string, base, head string) (*CommitsComparison, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/commits/index.html#compare-two-commits
+func (s *RepositoriesService) CompareCommits(ctx context.Context, owner, repo string, base, head string) (*CommitsComparison, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/compare/%v...%v", owner, repo, base, head)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -193,10 +194,10 @@ func (s *RepositoriesService) CompareCommits(owner, repo string, base, head stri
 	}
 
 	comp := new(CommitsComparison)
-	resp, err := s.client.Do(req, comp)
+	resp, err := s.client.Do(ctx, req, comp)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return comp, resp, err
+	return comp, resp, nil
 }

vendor/github.com/google/go-github/github/repos_contents.go

@@ -4,14 +4,14 @@
 // license that can be found in the LICENSE file.
 
 // Repository contents API methods.
-// http://developer.github.com/v3/repos/contents/
+// GitHub API docs: https://developer.github.com/v3/repos/contents/
 
 package github
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -64,20 +64,6 @@ func (r RepositoryContent) String() string {
 	return Stringify(r)
 }
 
-// Decode decodes the file content if it is base64 encoded.
-//
-// Deprecated: Use GetContent instead.
-func (r *RepositoryContent) Decode() ([]byte, error) {
-	if *r.Encoding != "base64" {
-		return nil, errors.New("cannot decode non-base64")
-	}
-	o, err := base64.StdEncoding.DecodeString(*r.Content)
-	if err != nil {
-		return nil, err
-	}
-	return o, nil
-}
-
 // GetContent returns the content of r, decoding it if necessary.
 func (r *RepositoryContent) GetContent() (string, error) {
 	var encoding string
@@ -101,8 +87,8 @@ func (r *RepositoryContent) GetContent() (string, error) {
 
 // GetReadme gets the Readme file for the repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/contents/#get-the-readme
-func (s *RepositoriesService) GetReadme(owner, repo string, opt *RepositoryContentGetOptions) (*RepositoryContent, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/contents/#get-the-readme
+func (s *RepositoriesService) GetReadme(ctx context.Context, owner, repo string, opt *RepositoryContentGetOptions) (*RepositoryContent, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/readme", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -113,21 +99,21 @@ func (s *RepositoriesService) GetReadme(owner, repo string, opt *RepositoryConte
 		return nil, nil, err
 	}
 	readme := new(RepositoryContent)
-	resp, err := s.client.Do(req, readme)
+	resp, err := s.client.Do(ctx, req, readme)
 	if err != nil {
 		return nil, resp, err
 	}
-	return readme, resp, err
+	return readme, resp, nil
 }
 
 // DownloadContents returns an io.ReadCloser that reads the contents of the
 // specified file. This function will work with files of any size, as opposed
 // to GetContents which is limited to 1 Mb files. It is the caller's
 // responsibility to close the ReadCloser.
-func (s *RepositoriesService) DownloadContents(owner, repo, filepath string, opt *RepositoryContentGetOptions) (io.ReadCloser, error) {
+func (s *RepositoriesService) DownloadContents(ctx context.Context, owner, repo, filepath string, opt *RepositoryContentGetOptions) (io.ReadCloser, error) {
 	dir := path.Dir(filepath)
 	filename := path.Base(filepath)
-	_, dirContents, _, err := s.GetContents(owner, repo, dir, opt)
+	_, dirContents, _, err := s.GetContents(ctx, owner, repo, dir, opt)
 	if err != nil {
 		return nil, err
 	}
@@ -153,8 +139,8 @@ func (s *RepositoriesService) DownloadContents(owner, repo, filepath string, opt
 // as possible, both result types will be returned but only one will contain a
 // value and the other will be nil.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/contents/#get-contents
-func (s *RepositoriesService) GetContents(owner, repo, path string, opt *RepositoryContentGetOptions) (fileContent *RepositoryContent, directoryContent []*RepositoryContent, resp *Response, err error) {
+// GitHub API docs: https://developer.github.com/v3/repos/contents/#get-contents
+func (s *RepositoriesService) GetContents(ctx context.Context, owner, repo, path string, opt *RepositoryContentGetOptions) (fileContent *RepositoryContent, directoryContent []*RepositoryContent, resp *Response, err error) {
 	escapedPath := (&url.URL{Path: path}).String()
 	u := fmt.Sprintf("repos/%s/%s/contents/%s", owner, repo, escapedPath)
 	u, err = addOptions(u, opt)
@@ -166,17 +152,17 @@ func (s *RepositoriesService) GetContents(owner, repo, path string, opt *Reposit
 		return nil, nil, nil, err
 	}
 	var rawJSON json.RawMessage
-	resp, err = s.client.Do(req, &rawJSON)
+	resp, err = s.client.Do(ctx, req, &rawJSON)
 	if err != nil {
 		return nil, nil, resp, err
 	}
 	fileUnmarshalError := json.Unmarshal(rawJSON, &fileContent)
 	if fileUnmarshalError == nil {
-		return fileContent, nil, resp, fileUnmarshalError
+		return fileContent, nil, resp, nil
 	}
 	directoryUnmarshalError := json.Unmarshal(rawJSON, &directoryContent)
 	if directoryUnmarshalError == nil {
-		return nil, directoryContent, resp, directoryUnmarshalError
+		return nil, directoryContent, resp, nil
 	}
 	return nil, nil, resp, fmt.Errorf("unmarshalling failed for both file and directory content: %s and %s ", fileUnmarshalError, directoryUnmarshalError)
 }
@@ -184,55 +170,55 @@ func (s *RepositoriesService) GetContents(owner, repo, path string, opt *Reposit
 // CreateFile creates a new file in a repository at the given path and returns
 // the commit and file metadata.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/contents/#create-a-file
-func (s *RepositoriesService) CreateFile(owner, repo, path string, opt *RepositoryContentFileOptions) (*RepositoryContentResponse, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/contents/#create-a-file
+func (s *RepositoriesService) CreateFile(ctx context.Context, owner, repo, path string, opt *RepositoryContentFileOptions) (*RepositoryContentResponse, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/contents/%s", owner, repo, path)
 	req, err := s.client.NewRequest("PUT", u, opt)
 	if err != nil {
 		return nil, nil, err
 	}
 	createResponse := new(RepositoryContentResponse)
-	resp, err := s.client.Do(req, createResponse)
+	resp, err := s.client.Do(ctx, req, createResponse)
 	if err != nil {
 		return nil, resp, err
 	}
-	return createResponse, resp, err
+	return createResponse, resp, nil
 }
 
 // UpdateFile updates a file in a repository at the given path and returns the
 // commit and file metadata. Requires the blob SHA of the file being updated.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/contents/#update-a-file
-func (s *RepositoriesService) UpdateFile(owner, repo, path string, opt *RepositoryContentFileOptions) (*RepositoryContentResponse, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/contents/#update-a-file
+func (s *RepositoriesService) UpdateFile(ctx context.Context, owner, repo, path string, opt *RepositoryContentFileOptions) (*RepositoryContentResponse, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/contents/%s", owner, repo, path)
 	req, err := s.client.NewRequest("PUT", u, opt)
 	if err != nil {
 		return nil, nil, err
 	}
 	updateResponse := new(RepositoryContentResponse)
-	resp, err := s.client.Do(req, updateResponse)
+	resp, err := s.client.Do(ctx, req, updateResponse)
 	if err != nil {
 		return nil, resp, err
 	}
-	return updateResponse, resp, err
+	return updateResponse, resp, nil
 }
 
 // DeleteFile deletes a file from a repository and returns the commit.
 // Requires the blob SHA of the file to be deleted.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/contents/#delete-a-file
-func (s *RepositoriesService) DeleteFile(owner, repo, path string, opt *RepositoryContentFileOptions) (*RepositoryContentResponse, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/contents/#delete-a-file
+func (s *RepositoriesService) DeleteFile(ctx context.Context, owner, repo, path string, opt *RepositoryContentFileOptions) (*RepositoryContentResponse, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/contents/%s", owner, repo, path)
 	req, err := s.client.NewRequest("DELETE", u, opt)
 	if err != nil {
 		return nil, nil, err
 	}
 	deleteResponse := new(RepositoryContentResponse)
-	resp, err := s.client.Do(req, deleteResponse)
+	resp, err := s.client.Do(ctx, req, deleteResponse)
 	if err != nil {
 		return nil, resp, err
 	}
-	return deleteResponse, resp, err
+	return deleteResponse, resp, nil
 }
 
 // archiveFormat is used to define the archive type when calling GetArchiveLink.
@@ -250,8 +236,8 @@ const (
 // repository. The archiveFormat can be specified by either the github.Tarball
 // or github.Zipball constant.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/contents/#get-archive-link
-func (s *RepositoriesService) GetArchiveLink(owner, repo string, archiveformat archiveFormat, opt *RepositoryContentGetOptions) (*url.URL, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/contents/#get-archive-link
+func (s *RepositoriesService) GetArchiveLink(ctx context.Context, owner, repo string, archiveformat archiveFormat, opt *RepositoryContentGetOptions) (*url.URL, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/%s", owner, repo, archiveformat)
 	if opt != nil && opt.Ref != "" {
 		u += fmt.Sprintf("/%s", opt.Ref)
@@ -262,6 +248,7 @@ func (s *RepositoriesService) GetArchiveLink(owner, repo string, archiveformat a
 	}
 	var resp *http.Response
 	// Use http.DefaultTransport if no custom Transport is configured
+	ctx, req = withContext(ctx, req)
 	if s.client.client.Transport == nil {
 		resp, err = http.DefaultTransport.RoundTrip(req)
 	} else {

vendor/github.com/google/go-github/github/repos_deployments.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 )
@@ -61,7 +62,7 @@ type DeploymentsListOptions struct {
 // ListDeployments lists the deployments of a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/deployments/#list-deployments
-func (s *RepositoriesService) ListDeployments(owner, repo string, opt *DeploymentsListOptions) ([]*Deployment, *Response, error) {
+func (s *RepositoriesService) ListDeployments(ctx context.Context, owner, repo string, opt *DeploymentsListOptions) ([]*Deployment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/deployments", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -73,19 +74,19 @@ func (s *RepositoriesService) ListDeployments(owner, repo string, opt *Deploymen
 		return nil, nil, err
 	}
 
-	deployments := new([]*Deployment)
-	resp, err := s.client.Do(req, deployments)
+	var deployments []*Deployment
+	resp, err := s.client.Do(ctx, req, &deployments)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *deployments, resp, err
+	return deployments, resp, nil
 }
 
 // GetDeployment returns a single deployment of a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/deployments/#get-a-single-deployment
-func (s *RepositoriesService) GetDeployment(owner, repo string, deploymentID int) (*Deployment, *Response, error) {
+func (s *RepositoriesService) GetDeployment(ctx context.Context, owner, repo string, deploymentID int) (*Deployment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/deployments/%v", owner, repo, deploymentID)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -94,18 +95,18 @@ func (s *RepositoriesService) GetDeployment(owner, repo string, deploymentID int
 	}
 
 	deployment := new(Deployment)
-	resp, err := s.client.Do(req, deployment)
+	resp, err := s.client.Do(ctx, req, deployment)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return deployment, resp, err
+	return deployment, resp, nil
 }
 
 // CreateDeployment creates a new deployment for a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/deployments/#create-a-deployment
-func (s *RepositoriesService) CreateDeployment(owner, repo string, request *DeploymentRequest) (*Deployment, *Response, error) {
+func (s *RepositoriesService) CreateDeployment(ctx context.Context, owner, repo string, request *DeploymentRequest) (*Deployment, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/deployments", owner, repo)
 
 	req, err := s.client.NewRequest("POST", u, request)
@@ -117,12 +118,12 @@ func (s *RepositoriesService) CreateDeployment(owner, repo string, request *Depl
 	req.Header.Set("Accept", mediaTypeDeploymentStatusPreview)
 
 	d := new(Deployment)
-	resp, err := s.client.Do(req, d)
+	resp, err := s.client.Do(ctx, req, d)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return d, resp, err
+	return d, resp, nil
 }
 
 // DeploymentStatus represents the status of a
@@ -144,7 +145,6 @@ type DeploymentStatus struct {
 // DeploymentStatusRequest represents a deployment request
 type DeploymentStatusRequest struct {
 	State          *string `json:"state,omitempty"`
-	TargetURL      *string `json:"target_url,omitempty"` // Deprecated. Use LogURL instead.
 	LogURL         *string `json:"log_url,omitempty"`
 	Description    *string `json:"description,omitempty"`
 	EnvironmentURL *string `json:"environment_url,omitempty"`
@@ -154,7 +154,7 @@ type DeploymentStatusRequest struct {
 // ListDeploymentStatuses lists the statuses of a given deployment of a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/deployments/#list-deployment-statuses
-func (s *RepositoriesService) ListDeploymentStatuses(owner, repo string, deployment int, opt *ListOptions) ([]*DeploymentStatus, *Response, error) {
+func (s *RepositoriesService) ListDeploymentStatuses(ctx context.Context, owner, repo string, deployment int, opt *ListOptions) ([]*DeploymentStatus, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/deployments/%v/statuses", owner, repo, deployment)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -166,19 +166,19 @@ func (s *RepositoriesService) ListDeploymentStatuses(owner, repo string, deploym
 		return nil, nil, err
 	}
 
-	statuses := new([]*DeploymentStatus)
-	resp, err := s.client.Do(req, statuses)
+	var statuses []*DeploymentStatus
+	resp, err := s.client.Do(ctx, req, &statuses)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *statuses, resp, err
+	return statuses, resp, nil
 }
 
 // GetDeploymentStatus returns a single deployment status of a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/deployments/#get-a-single-deployment-status
-func (s *RepositoriesService) GetDeploymentStatus(owner, repo string, deploymentID, deploymentStatusID int) (*DeploymentStatus, *Response, error) {
+func (s *RepositoriesService) GetDeploymentStatus(ctx context.Context, owner, repo string, deploymentID, deploymentStatusID int) (*DeploymentStatus, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/deployments/%v/statuses/%v", owner, repo, deploymentID, deploymentStatusID)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -190,18 +190,18 @@ func (s *RepositoriesService) GetDeploymentStatus(owner, repo string, deployment
 	req.Header.Set("Accept", mediaTypeDeploymentStatusPreview)
 
 	d := new(DeploymentStatus)
-	resp, err := s.client.Do(req, d)
+	resp, err := s.client.Do(ctx, req, d)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return d, resp, err
+	return d, resp, nil
 }
 
 // CreateDeploymentStatus creates a new status for a deployment.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/deployments/#create-a-deployment-status
-func (s *RepositoriesService) CreateDeploymentStatus(owner, repo string, deployment int, request *DeploymentStatusRequest) (*DeploymentStatus, *Response, error) {
+func (s *RepositoriesService) CreateDeploymentStatus(ctx context.Context, owner, repo string, deployment int, request *DeploymentStatusRequest) (*DeploymentStatus, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/deployments/%v/statuses", owner, repo, deployment)
 
 	req, err := s.client.NewRequest("POST", u, request)
@@ -213,10 +213,10 @@ func (s *RepositoriesService) CreateDeploymentStatus(owner, repo string, deploym
 	req.Header.Set("Accept", mediaTypeDeploymentStatusPreview)
 
 	d := new(DeploymentStatus)
-	resp, err := s.client.Do(req, d)
+	resp, err := s.client.Do(ctx, req, d)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return d, resp, err
+	return d, resp, nil
 }

vendor/github.com/google/go-github/github/repos_forks.go

@@ -5,13 +5,16 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // RepositoryListForksOptions specifies the optional parameters to the
 // RepositoriesService.ListForks method.
 type RepositoryListForksOptions struct {
-	// How to sort the forks list.  Possible values are: newest, oldest,
-	// watchers.  Default is "newest".
+	// How to sort the forks list. Possible values are: newest, oldest,
+	// watchers. Default is "newest".
 	Sort string `url:"sort,omitempty"`
 
 	ListOptions
@@ -19,8 +22,8 @@ type RepositoryListForksOptions struct {
 
 // ListForks lists the forks of the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/forks/#list-forks
-func (s *RepositoriesService) ListForks(owner, repo string, opt *RepositoryListForksOptions) ([]*Repository, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/forks/#list-forks
+func (s *RepositoriesService) ListForks(ctx context.Context, owner, repo string, opt *RepositoryListForksOptions) ([]*Repository, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/forks", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -32,13 +35,13 @@ func (s *RepositoriesService) ListForks(owner, repo string, opt *RepositoryListF
 		return nil, nil, err
 	}
 
-	repos := new([]*Repository)
-	resp, err := s.client.Do(req, repos)
+	var repos []*Repository
+	resp, err := s.client.Do(ctx, req, &repos)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *repos, resp, err
+	return repos, resp, nil
 }
 
 // RepositoryCreateForkOptions specifies the optional parameters to the
@@ -57,7 +60,7 @@ type RepositoryCreateForkOptions struct {
 // in a successful request.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/forks/#create-a-fork
-func (s *RepositoriesService) CreateFork(owner, repo string, opt *RepositoryCreateForkOptions) (*Repository, *Response, error) {
+func (s *RepositoriesService) CreateFork(ctx context.Context, owner, repo string, opt *RepositoryCreateForkOptions) (*Repository, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/forks", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -70,10 +73,10 @@ func (s *RepositoriesService) CreateFork(owner, repo string, opt *RepositoryCrea
 	}
 
 	fork := new(Repository)
-	resp, err := s.client.Do(req, fork)
+	resp, err := s.client.Do(ctx, req, fork)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return fork, resp, err
+	return fork, resp, nil
 }

vendor/github.com/google/go-github/github/repos_hooks.go

@@ -6,14 +6,15 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
 
 // WebHookPayload represents the data that is received from GitHub when a push
-// event hook is triggered.  The format of these payloads pre-date most of the
+// event hook is triggered. The format of these payloads pre-date most of the
 // GitHub v3 API, so there are lots of minor incompatibilities with the types
-// defined in the rest of the API.  Therefore, several types are duplicated
+// defined in the rest of the API. Therefore, several types are duplicated
 // here to account for these differences.
 //
 // GitHub API docs: https://help.github.com/articles/post-receive-hooks
@@ -55,7 +56,7 @@ func (w WebHookCommit) String() string {
 }
 
 // WebHookAuthor represents the author or committer of a commit, as specified
-// in a WebHookCommit.  The commit author may not correspond to a GitHub User.
+// in a WebHookCommit. The commit author may not correspond to a GitHub User.
 type WebHookAuthor struct {
 	Email    *string `json:"email,omitempty"`
 	Name     *string `json:"name,omitempty"`
@@ -85,8 +86,8 @@ func (h Hook) String() string {
 // CreateHook creates a Hook for the specified repository.
 // Name and Config are required fields.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/hooks/#create-a-hook
-func (s *RepositoriesService) CreateHook(owner, repo string, hook *Hook) (*Hook, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/hooks/#create-a-hook
+func (s *RepositoriesService) CreateHook(ctx context.Context, owner, repo string, hook *Hook) (*Hook, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks", owner, repo)
 	req, err := s.client.NewRequest("POST", u, hook)
 	if err != nil {
@@ -94,18 +95,18 @@ func (s *RepositoriesService) CreateHook(owner, repo string, hook *Hook) (*Hook,
 	}
 
 	h := new(Hook)
-	resp, err := s.client.Do(req, h)
+	resp, err := s.client.Do(ctx, req, h)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return h, resp, err
+	return h, resp, nil
 }
 
 // ListHooks lists all Hooks for the specified repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/hooks/#list
-func (s *RepositoriesService) ListHooks(owner, repo string, opt *ListOptions) ([]*Hook, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/hooks/#list
+func (s *RepositoriesService) ListHooks(ctx context.Context, owner, repo string, opt *ListOptions) ([]*Hook, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -117,80 +118,75 @@ func (s *RepositoriesService) ListHooks(owner, repo string, opt *ListOptions) ([
 		return nil, nil, err
 	}
 
-	hooks := new([]*Hook)
-	resp, err := s.client.Do(req, hooks)
+	var hooks []*Hook
+	resp, err := s.client.Do(ctx, req, &hooks)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *hooks, resp, err
+	return hooks, resp, nil
 }
 
 // GetHook returns a single specified Hook.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/hooks/#get-single-hook
-func (s *RepositoriesService) GetHook(owner, repo string, id int) (*Hook, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/hooks/#get-single-hook
+func (s *RepositoriesService) GetHook(ctx context.Context, owner, repo string, id int) (*Hook, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks/%d", owner, repo, id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 	hook := new(Hook)
-	resp, err := s.client.Do(req, hook)
+	resp, err := s.client.Do(ctx, req, hook)
 	return hook, resp, err
 }
 
 // EditHook updates a specified Hook.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/hooks/#edit-a-hook
-func (s *RepositoriesService) EditHook(owner, repo string, id int, hook *Hook) (*Hook, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/hooks/#edit-a-hook
+func (s *RepositoriesService) EditHook(ctx context.Context, owner, repo string, id int, hook *Hook) (*Hook, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks/%d", owner, repo, id)
 	req, err := s.client.NewRequest("PATCH", u, hook)
 	if err != nil {
 		return nil, nil, err
 	}
 	h := new(Hook)
-	resp, err := s.client.Do(req, h)
+	resp, err := s.client.Do(ctx, req, h)
 	return h, resp, err
 }
 
 // DeleteHook deletes a specified Hook.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/hooks/#delete-a-hook
-func (s *RepositoriesService) DeleteHook(owner, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/hooks/#delete-a-hook
+func (s *RepositoriesService) DeleteHook(ctx context.Context, owner, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks/%d", owner, repo, id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // PingHook triggers a 'ping' event to be sent to the Hook.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/hooks/#ping-a-hook
-func (s *RepositoriesService) PingHook(owner, repo string, id int) (*Response, error) {
+func (s *RepositoriesService) PingHook(ctx context.Context, owner, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks/%d/pings", owner, repo, id)
 	req, err := s.client.NewRequest("POST", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // TestHook triggers a test Hook by github.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/hooks/#test-a-push-hook
-func (s *RepositoriesService) TestHook(owner, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/hooks/#test-a-push-hook
+func (s *RepositoriesService) TestHook(ctx context.Context, owner, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/hooks/%d/tests", owner, repo, id)
 	req, err := s.client.NewRequest("POST", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
-}
-
-// ListServiceHooks is deprecated.  Use Client.ListServiceHooks instead.
-func (s *RepositoriesService) ListServiceHooks() ([]*ServiceHook, *Response, error) {
-	return s.client.ListServiceHooks()
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/repos_invitations.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // RepositoryInvitation represents an invitation to collaborate on a repo.
 type RepositoryInvitation struct {
@@ -25,8 +28,8 @@ type RepositoryInvitation struct {
 // ListInvitations lists all currently-open repository invitations.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/invitations/#list-invitations-for-a-repository
-func (s *RepositoriesService) ListInvitations(repoID int, opt *ListOptions) ([]*RepositoryInvitation, *Response, error) {
-	u := fmt.Sprintf("repositories/%v/invitations", repoID)
+func (s *RepositoriesService) ListInvitations(ctx context.Context, owner, repo string, opt *ListOptions) ([]*RepositoryInvitation, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/invitations", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
 		return nil, nil, err
@@ -41,19 +44,19 @@ func (s *RepositoriesService) ListInvitations(repoID int, opt *ListOptions) ([]*
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
 	invites := []*RepositoryInvitation{}
-	resp, err := s.client.Do(req, &invites)
+	resp, err := s.client.Do(ctx, req, &invites)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return invites, resp, err
+	return invites, resp, nil
 }
 
 // DeleteInvitation deletes a repository invitation.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/invitations/#delete-a-repository-invitation
-func (s *RepositoriesService) DeleteInvitation(repoID, invitationID int) (*Response, error) {
-	u := fmt.Sprintf("repositories/%v/invitations/%v", repoID, invitationID)
+func (s *RepositoriesService) DeleteInvitation(ctx context.Context, owner, repo string, invitationID int) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/invitations/%v", owner, repo, invitationID)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
@@ -62,7 +65,7 @@ func (s *RepositoriesService) DeleteInvitation(repoID, invitationID int) (*Respo
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // UpdateInvitation updates the permissions associated with a repository
@@ -72,11 +75,11 @@ func (s *RepositoriesService) DeleteInvitation(repoID, invitationID int) (*Respo
 // on the repository. Possible values are: "read", "write", "admin".
 //
 // GitHub API docs: https://developer.github.com/v3/repos/invitations/#update-a-repository-invitation
-func (s *RepositoriesService) UpdateInvitation(repoID, invitationID int, permissions string) (*RepositoryInvitation, *Response, error) {
+func (s *RepositoriesService) UpdateInvitation(ctx context.Context, owner, repo string, invitationID int, permissions string) (*RepositoryInvitation, *Response, error) {
 	opts := &struct {
 		Permissions string `json:"permissions"`
 	}{Permissions: permissions}
-	u := fmt.Sprintf("repositories/%v/invitations/%v", repoID, invitationID)
+	u := fmt.Sprintf("repos/%v/%v/invitations/%v", owner, repo, invitationID)
 	req, err := s.client.NewRequest("PATCH", u, opts)
 	if err != nil {
 		return nil, nil, err
@@ -86,6 +89,6 @@ func (s *RepositoriesService) UpdateInvitation(repoID, invitationID int, permiss
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
 	invite := &RepositoryInvitation{}
-	resp, err := s.client.Do(req, invite)
+	resp, err := s.client.Do(ctx, req, invite)
 	return invite, resp, err
 }

vendor/github.com/google/go-github/github/repos_keys.go

@@ -5,14 +5,17 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // The Key type is defined in users_keys.go
 
 // ListKeys lists the deploy keys for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/keys/#list
-func (s *RepositoriesService) ListKeys(owner string, repo string, opt *ListOptions) ([]*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/keys/#list
+func (s *RepositoriesService) ListKeys(ctx context.Context, owner string, repo string, opt *ListOptions) ([]*Key, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/keys", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -24,19 +27,19 @@ func (s *RepositoriesService) ListKeys(owner string, repo string, opt *ListOptio
 		return nil, nil, err
 	}
 
-	keys := new([]*Key)
-	resp, err := s.client.Do(req, keys)
+	var keys []*Key
+	resp, err := s.client.Do(ctx, req, &keys)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *keys, resp, err
+	return keys, resp, nil
 }
 
 // GetKey fetches a single deploy key.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/keys/#get
-func (s *RepositoriesService) GetKey(owner string, repo string, id int) (*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/keys/#get
+func (s *RepositoriesService) GetKey(ctx context.Context, owner string, repo string, id int) (*Key, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/keys/%v", owner, repo, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -45,18 +48,18 @@ func (s *RepositoriesService) GetKey(owner string, repo string, id int) (*Key, *
 	}
 
 	key := new(Key)
-	resp, err := s.client.Do(req, key)
+	resp, err := s.client.Do(ctx, req, key)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return key, resp, err
+	return key, resp, nil
 }
 
 // CreateKey adds a deploy key for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/keys/#create
-func (s *RepositoriesService) CreateKey(owner string, repo string, key *Key) (*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/keys/#create
+func (s *RepositoriesService) CreateKey(ctx context.Context, owner string, repo string, key *Key) (*Key, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/keys", owner, repo)
 
 	req, err := s.client.NewRequest("POST", u, key)
@@ -65,18 +68,18 @@ func (s *RepositoriesService) CreateKey(owner string, repo string, key *Key) (*K
 	}
 
 	k := new(Key)
-	resp, err := s.client.Do(req, k)
+	resp, err := s.client.Do(ctx, req, k)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return k, resp, err
+	return k, resp, nil
 }
 
 // EditKey edits a deploy key.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/keys/#edit
-func (s *RepositoriesService) EditKey(owner string, repo string, id int, key *Key) (*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/keys/#edit
+func (s *RepositoriesService) EditKey(ctx context.Context, owner string, repo string, id int, key *Key) (*Key, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/keys/%v", owner, repo, id)
 
 	req, err := s.client.NewRequest("PATCH", u, key)
@@ -85,18 +88,18 @@ func (s *RepositoriesService) EditKey(owner string, repo string, id int, key *Ke
 	}
 
 	k := new(Key)
-	resp, err := s.client.Do(req, k)
+	resp, err := s.client.Do(ctx, req, k)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return k, resp, err
+	return k, resp, nil
 }
 
 // DeleteKey deletes a deploy key.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/keys/#delete
-func (s *RepositoriesService) DeleteKey(owner string, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/keys/#delete
+func (s *RepositoriesService) DeleteKey(ctx context.Context, owner string, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/keys/%v", owner, repo, id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -104,5 +107,5 @@ func (s *RepositoriesService) DeleteKey(owner string, repo string, id int) (*Res
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/repos_merging.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 )
 
@@ -20,7 +21,7 @@ type RepositoryMergeRequest struct {
 // Merge a branch in the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/merging/#perform-a-merge
-func (s *RepositoriesService) Merge(owner, repo string, request *RepositoryMergeRequest) (*RepositoryCommit, *Response, error) {
+func (s *RepositoriesService) Merge(ctx context.Context, owner, repo string, request *RepositoryMergeRequest) (*RepositoryCommit, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/merges", owner, repo)
 	req, err := s.client.NewRequest("POST", u, request)
 	if err != nil {
@@ -28,10 +29,10 @@ func (s *RepositoriesService) Merge(owner, repo string, request *RepositoryMerge
 	}
 
 	commit := new(RepositoryCommit)
-	resp, err := s.client.Do(req, commit)
+	resp, err := s.client.Do(ctx, req, commit)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return commit, resp, err
+	return commit, resp, nil
 }

vendor/github.com/google/go-github/github/repos_pages.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Pages represents a GitHub Pages site configuration.
 type Pages struct {
@@ -36,7 +39,7 @@ type PagesBuild struct {
 // GetPagesInfo fetches information about a GitHub Pages site.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/pages/#get-information-about-a-pages-site
-func (s *RepositoriesService) GetPagesInfo(owner, repo string) (*Pages, *Response, error) {
+func (s *RepositoriesService) GetPagesInfo(ctx context.Context, owner, repo string) (*Pages, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pages", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -47,18 +50,18 @@ func (s *RepositoriesService) GetPagesInfo(owner, repo string) (*Pages, *Respons
 	req.Header.Set("Accept", mediaTypePagesPreview)
 
 	site := new(Pages)
-	resp, err := s.client.Do(req, site)
+	resp, err := s.client.Do(ctx, req, site)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return site, resp, err
+	return site, resp, nil
 }
 
 // ListPagesBuilds lists the builds for a GitHub Pages site.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/pages/#list-pages-builds
-func (s *RepositoriesService) ListPagesBuilds(owner, repo string) ([]*PagesBuild, *Response, error) {
+func (s *RepositoriesService) ListPagesBuilds(ctx context.Context, owner, repo string) ([]*PagesBuild, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pages/builds", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -66,18 +69,18 @@ func (s *RepositoriesService) ListPagesBuilds(owner, repo string) ([]*PagesBuild
 	}
 
 	var pages []*PagesBuild
-	resp, err := s.client.Do(req, &pages)
+	resp, err := s.client.Do(ctx, req, &pages)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return pages, resp, err
+	return pages, resp, nil
 }
 
 // GetLatestPagesBuild fetches the latest build information for a GitHub pages site.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/pages/#list-latest-pages-build
-func (s *RepositoriesService) GetLatestPagesBuild(owner, repo string) (*PagesBuild, *Response, error) {
+func (s *RepositoriesService) GetLatestPagesBuild(ctx context.Context, owner, repo string) (*PagesBuild, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pages/builds/latest", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -85,18 +88,18 @@ func (s *RepositoriesService) GetLatestPagesBuild(owner, repo string) (*PagesBui
 	}
 
 	build := new(PagesBuild)
-	resp, err := s.client.Do(req, build)
+	resp, err := s.client.Do(ctx, req, build)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return build, resp, err
+	return build, resp, nil
 }
 
 // GetPageBuild fetches the specific build information for a GitHub pages site.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/pages/#list-a-specific-pages-build
-func (s *RepositoriesService) GetPageBuild(owner, repo string, id int) (*PagesBuild, *Response, error) {
+func (s *RepositoriesService) GetPageBuild(ctx context.Context, owner, repo string, id int) (*PagesBuild, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pages/builds/%v", owner, repo, id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -104,18 +107,18 @@ func (s *RepositoriesService) GetPageBuild(owner, repo string, id int) (*PagesBu
 	}
 
 	build := new(PagesBuild)
-	resp, err := s.client.Do(req, build)
+	resp, err := s.client.Do(ctx, req, build)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return build, resp, err
+	return build, resp, nil
 }
 
 // RequestPageBuild requests a build of a GitHub Pages site without needing to push new commit.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/pages/#request-a-page-build
-func (s *RepositoriesService) RequestPageBuild(owner, repo string) (*PagesBuild, *Response, error) {
+func (s *RepositoriesService) RequestPageBuild(ctx context.Context, owner, repo string) (*PagesBuild, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/pages/builds", owner, repo)
 	req, err := s.client.NewRequest("POST", u, nil)
 	if err != nil {
@@ -126,10 +129,10 @@ func (s *RepositoriesService) RequestPageBuild(owner, repo string) (*PagesBuild,
 	req.Header.Set("Accept", mediaTypePagesPreview)
 
 	build := new(PagesBuild)
-	resp, err := s.client.Do(req, build)
+	resp, err := s.client.Do(ctx, req, build)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return build, resp, err
+	return build, resp, nil
 }

vendor/github.com/google/go-github/github/repos_projects.go

@@ -1,16 +1,28 @@
-// Copyright 2016 The go-github AUTHORS. All rights reserved.
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
+
+// ProjectListOptions specifies the optional parameters to the
+// OrganizationsService.ListProjects and RepositoriesService.ListProjects methods.
+type ProjectListOptions struct {
+	// Indicates the state of the projects to return. Can be either open, closed, or all. Default: open
+	State string `url:"state,omitempty"`
+
+	ListOptions
+}
 
 // ListProjects lists the projects for a repo.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/#list-repository-projects
-func (s *RepositoriesService) ListProjects(owner, repo string, opt *ListOptions) ([]*Project, *Response, error) {
+func (s *RepositoriesService) ListProjects(ctx context.Context, owner, repo string, opt *ProjectListOptions) ([]*Project, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/projects", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -25,19 +37,19 @@ func (s *RepositoriesService) ListProjects(owner, repo string, opt *ListOptions)
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
-	projects := []*Project{}
-	resp, err := s.client.Do(req, &projects)
+	var projects []*Project
+	resp, err := s.client.Do(ctx, req, &projects)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return projects, resp, err
+	return projects, resp, nil
 }
 
 // CreateProject creates a GitHub Project for the specified repository.
 //
 // GitHub API docs: https://developer.github.com/v3/projects/#create-a-repository-project
-func (s *RepositoriesService) CreateProject(owner, repo string, opt *ProjectOptions) (*Project, *Response, error) {
+func (s *RepositoriesService) CreateProject(ctx context.Context, owner, repo string, opt *ProjectOptions) (*Project, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/projects", owner, repo)
 	req, err := s.client.NewRequest("POST", u, opt)
 	if err != nil {
@@ -48,10 +60,10 @@ func (s *RepositoriesService) CreateProject(owner, repo string, opt *ProjectOpti
 	req.Header.Set("Accept", mediaTypeProjectsPreview)
 
 	project := &Project{}
-	resp, err := s.client.Do(req, project)
+	resp, err := s.client.Do(ctx, req, project)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return project, resp, err
+	return project, resp, nil
 }

vendor/github.com/google/go-github/github/repos_releases.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -41,7 +42,7 @@ func (r RepositoryRelease) String() string {
 	return Stringify(r)
 }
 
-// ReleaseAsset represents a Github release asset in a repository.
+// ReleaseAsset represents a GitHub release asset in a repository.
 type ReleaseAsset struct {
 	ID                 *int       `json:"id,omitempty"`
 	URL                *string    `json:"url,omitempty"`
@@ -63,8 +64,8 @@ func (r ReleaseAsset) String() string {
 
 // ListReleases lists the releases for a repository.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/releases/#list-releases-for-a-repository
-func (s *RepositoriesService) ListReleases(owner, repo string, opt *ListOptions) ([]*RepositoryRelease, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository
+func (s *RepositoriesService) ListReleases(ctx context.Context, owner, repo string, opt *ListOptions) ([]*RepositoryRelease, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -76,56 +77,56 @@ func (s *RepositoriesService) ListReleases(owner, repo string, opt *ListOptions)
 		return nil, nil, err
 	}
 
-	releases := new([]*RepositoryRelease)
-	resp, err := s.client.Do(req, releases)
+	var releases []*RepositoryRelease
+	resp, err := s.client.Do(ctx, req, &releases)
 	if err != nil {
 		return nil, resp, err
 	}
-	return *releases, resp, err
+	return releases, resp, nil
 }
 
 // GetRelease fetches a single release.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/releases/#get-a-single-release
-func (s *RepositoriesService) GetRelease(owner, repo string, id int) (*RepositoryRelease, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#get-a-single-release
+func (s *RepositoriesService) GetRelease(ctx context.Context, owner, repo string, id int) (*RepositoryRelease, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/%d", owner, repo, id)
-	return s.getSingleRelease(u)
+	return s.getSingleRelease(ctx, u)
 }
 
 // GetLatestRelease fetches the latest published release for the repository.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/releases/#get-the-latest-release
-func (s *RepositoriesService) GetLatestRelease(owner, repo string) (*RepositoryRelease, *Response, error) {
+func (s *RepositoriesService) GetLatestRelease(ctx context.Context, owner, repo string) (*RepositoryRelease, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/latest", owner, repo)
-	return s.getSingleRelease(u)
+	return s.getSingleRelease(ctx, u)
 }
 
 // GetReleaseByTag fetches a release with the specified tag.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/releases/#get-a-release-by-tag-name
-func (s *RepositoriesService) GetReleaseByTag(owner, repo, tag string) (*RepositoryRelease, *Response, error) {
+func (s *RepositoriesService) GetReleaseByTag(ctx context.Context, owner, repo, tag string) (*RepositoryRelease, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/tags/%s", owner, repo, tag)
-	return s.getSingleRelease(u)
+	return s.getSingleRelease(ctx, u)
 }
 
-func (s *RepositoriesService) getSingleRelease(url string) (*RepositoryRelease, *Response, error) {
+func (s *RepositoriesService) getSingleRelease(ctx context.Context, url string) (*RepositoryRelease, *Response, error) {
 	req, err := s.client.NewRequest("GET", url, nil)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	release := new(RepositoryRelease)
-	resp, err := s.client.Do(req, release)
+	resp, err := s.client.Do(ctx, req, release)
 	if err != nil {
 		return nil, resp, err
 	}
-	return release, resp, err
+	return release, resp, nil
 }
 
 // CreateRelease adds a new release for a repository.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#create-a-release
-func (s *RepositoriesService) CreateRelease(owner, repo string, release *RepositoryRelease) (*RepositoryRelease, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#create-a-release
+func (s *RepositoriesService) CreateRelease(ctx context.Context, owner, repo string, release *RepositoryRelease) (*RepositoryRelease, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases", owner, repo)
 
 	req, err := s.client.NewRequest("POST", u, release)
@@ -134,17 +135,17 @@ func (s *RepositoriesService) CreateRelease(owner, repo string, release *Reposit
 	}
 
 	r := new(RepositoryRelease)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
-	return r, resp, err
+	return r, resp, nil
 }
 
 // EditRelease edits a repository release.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#edit-a-release
-func (s *RepositoriesService) EditRelease(owner, repo string, id int, release *RepositoryRelease) (*RepositoryRelease, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#edit-a-release
+func (s *RepositoriesService) EditRelease(ctx context.Context, owner, repo string, id int, release *RepositoryRelease) (*RepositoryRelease, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("PATCH", u, release)
@@ -153,30 +154,30 @@ func (s *RepositoriesService) EditRelease(owner, repo string, id int, release *R
 	}
 
 	r := new(RepositoryRelease)
-	resp, err := s.client.Do(req, r)
+	resp, err := s.client.Do(ctx, req, r)
 	if err != nil {
 		return nil, resp, err
 	}
-	return r, resp, err
+	return r, resp, nil
 }
 
 // DeleteRelease delete a single release from a repository.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#delete-a-release
-func (s *RepositoriesService) DeleteRelease(owner, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#delete-a-release
+func (s *RepositoriesService) DeleteRelease(ctx context.Context, owner, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // ListReleaseAssets lists the release's assets.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#list-assets-for-a-release
-func (s *RepositoriesService) ListReleaseAssets(owner, repo string, id int, opt *ListOptions) ([]*ReleaseAsset, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#list-assets-for-a-release
+func (s *RepositoriesService) ListReleaseAssets(ctx context.Context, owner, repo string, id int, opt *ListOptions) ([]*ReleaseAsset, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/%d/assets", owner, repo, id)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -188,18 +189,18 @@ func (s *RepositoriesService) ListReleaseAssets(owner, repo string, id int, opt
 		return nil, nil, err
 	}
 
-	assets := new([]*ReleaseAsset)
-	resp, err := s.client.Do(req, assets)
+	var assets []*ReleaseAsset
+	resp, err := s.client.Do(ctx, req, &assets)
 	if err != nil {
-		return nil, resp, nil
+		return nil, resp, err
 	}
-	return *assets, resp, err
+	return assets, resp, nil
 }
 
 // GetReleaseAsset fetches a single release asset.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#get-a-single-release-asset
-func (s *RepositoriesService) GetReleaseAsset(owner, repo string, id int) (*ReleaseAsset, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#get-a-single-release-asset
+func (s *RepositoriesService) GetReleaseAsset(ctx context.Context, owner, repo string, id int) (*ReleaseAsset, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/assets/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -208,11 +209,11 @@ func (s *RepositoriesService) GetReleaseAsset(owner, repo string, id int) (*Rele
 	}
 
 	asset := new(ReleaseAsset)
-	resp, err := s.client.Do(req, asset)
+	resp, err := s.client.Do(ctx, req, asset)
 	if err != nil {
-		return nil, resp, nil
+		return nil, resp, err
 	}
-	return asset, resp, err
+	return asset, resp, nil
 }
 
 // DownloadReleaseAsset downloads a release asset or returns a redirect URL.
@@ -222,8 +223,8 @@ func (s *RepositoriesService) GetReleaseAsset(owner, repo string, id int) (*Rele
 // If a redirect is returned, the redirect URL will be returned as a string instead
 // of the io.ReadCloser. Exactly one of rc and redirectURL will be zero.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#get-a-single-release-asset
-func (s *RepositoriesService) DownloadReleaseAsset(owner, repo string, id int) (rc io.ReadCloser, redirectURL string, err error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#get-a-single-release-asset
+func (s *RepositoriesService) DownloadReleaseAsset(ctx context.Context, owner, repo string, id int) (rc io.ReadCloser, redirectURL string, err error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/assets/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -243,12 +244,13 @@ func (s *RepositoriesService) DownloadReleaseAsset(owner, repo string, id int) (
 	}
 	defer func() { s.client.client.CheckRedirect = saveRedirect }()
 
+	ctx, req = withContext(ctx, req)
 	resp, err := s.client.client.Do(req)
 	if err != nil {
 		if !strings.Contains(err.Error(), "disable redirect") {
 			return nil, "", err
 		}
-		return nil, loc, nil
+		return nil, loc, nil // Intentionally return no error with valid redirect URL.
 	}
 
 	if err := CheckResponse(resp); err != nil {
@@ -261,8 +263,8 @@ func (s *RepositoriesService) DownloadReleaseAsset(owner, repo string, id int) (
 
 // EditReleaseAsset edits a repository release asset.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#edit-a-release-asset
-func (s *RepositoriesService) EditReleaseAsset(owner, repo string, id int, release *ReleaseAsset) (*ReleaseAsset, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#edit-a-release-asset
+func (s *RepositoriesService) EditReleaseAsset(ctx context.Context, owner, repo string, id int, release *ReleaseAsset) (*ReleaseAsset, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/assets/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("PATCH", u, release)
@@ -271,31 +273,31 @@ func (s *RepositoriesService) EditReleaseAsset(owner, repo string, id int, relea
 	}
 
 	asset := new(ReleaseAsset)
-	resp, err := s.client.Do(req, asset)
+	resp, err := s.client.Do(ctx, req, asset)
 	if err != nil {
 		return nil, resp, err
 	}
-	return asset, resp, err
+	return asset, resp, nil
 }
 
 // DeleteReleaseAsset delete a single release asset from a repository.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#delete-a-release-asset
-func (s *RepositoriesService) DeleteReleaseAsset(owner, repo string, id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#delete-a-release-asset
+func (s *RepositoriesService) DeleteReleaseAsset(ctx context.Context, owner, repo string, id int) (*Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/assets/%d", owner, repo, id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // UploadReleaseAsset creates an asset by uploading a file into a release repository.
 // To upload assets that cannot be represented by an os.File, call NewUploadRequest directly.
 //
-// GitHub API docs : http://developer.github.com/v3/repos/releases/#upload-a-release-asset
-func (s *RepositoriesService) UploadReleaseAsset(owner, repo string, id int, opt *UploadOptions, file *os.File) (*ReleaseAsset, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/releases/#upload-a-release-asset
+func (s *RepositoriesService) UploadReleaseAsset(ctx context.Context, owner, repo string, id int, opt *UploadOptions, file *os.File) (*ReleaseAsset, *Response, error) {
 	u := fmt.Sprintf("repos/%s/%s/releases/%d/assets", owner, repo, id)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -317,9 +319,9 @@ func (s *RepositoriesService) UploadReleaseAsset(owner, repo string, id int, opt
 	}
 
 	asset := new(ReleaseAsset)
-	resp, err := s.client.Do(req, asset)
+	resp, err := s.client.Do(ctx, req, asset)
 	if err != nil {
 		return nil, resp, err
 	}
-	return asset, resp, err
+	return asset, resp, nil
 }

vendor/github.com/google/go-github/github/repos_stats.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -44,8 +45,8 @@ func (w WeeklyStats) String() string {
 // it is now computing the requested statistics. A follow up request, after a
 // delay of a second or so, should result in a successful request.
 //
-// GitHub API Docs: https://developer.github.com/v3/repos/statistics/#contributors
-func (s *RepositoriesService) ListContributorsStats(owner, repo string) ([]*ContributorStats, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statistics/#contributors
+func (s *RepositoriesService) ListContributorsStats(ctx context.Context, owner, repo string) ([]*ContributorStats, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/stats/contributors", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -53,12 +54,12 @@ func (s *RepositoriesService) ListContributorsStats(owner, repo string) ([]*Cont
 	}
 
 	var contributorStats []*ContributorStats
-	resp, err := s.client.Do(req, &contributorStats)
+	resp, err := s.client.Do(ctx, req, &contributorStats)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return contributorStats, resp, err
+	return contributorStats, resp, nil
 }
 
 // WeeklyCommitActivity represents the weekly commit activity for a repository.
@@ -83,8 +84,8 @@ func (w WeeklyCommitActivity) String() string {
 // it is now computing the requested statistics. A follow up request, after a
 // delay of a second or so, should result in a successful request.
 //
-// GitHub API Docs: https://developer.github.com/v3/repos/statistics/#commit-activity
-func (s *RepositoriesService) ListCommitActivity(owner, repo string) ([]*WeeklyCommitActivity, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statistics/#commit-activity
+func (s *RepositoriesService) ListCommitActivity(ctx context.Context, owner, repo string) ([]*WeeklyCommitActivity, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/stats/commit_activity", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -92,16 +93,16 @@ func (s *RepositoriesService) ListCommitActivity(owner, repo string) ([]*WeeklyC
 	}
 
 	var weeklyCommitActivity []*WeeklyCommitActivity
-	resp, err := s.client.Do(req, &weeklyCommitActivity)
+	resp, err := s.client.Do(ctx, req, &weeklyCommitActivity)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return weeklyCommitActivity, resp, err
+	return weeklyCommitActivity, resp, nil
 }
 
 // ListCodeFrequency returns a weekly aggregate of the number of additions and
-// deletions pushed to a repository.  Returned WeeklyStats will contain
+// deletions pushed to a repository. Returned WeeklyStats will contain
 // additions and deletions, but not total commits.
 //
 // If this is the first time these statistics are requested for the given
@@ -110,8 +111,8 @@ func (s *RepositoriesService) ListCommitActivity(owner, repo string) ([]*WeeklyC
 // it is now computing the requested statistics. A follow up request, after a
 // delay of a second or so, should result in a successful request.
 //
-// GitHub API Docs: https://developer.github.com/v3/repos/statistics/#code-frequency
-func (s *RepositoriesService) ListCodeFrequency(owner, repo string) ([]*WeeklyStats, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statistics/#code-frequency
+func (s *RepositoriesService) ListCodeFrequency(ctx context.Context, owner, repo string) ([]*WeeklyStats, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/stats/code_frequency", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -119,7 +120,7 @@ func (s *RepositoriesService) ListCodeFrequency(owner, repo string) ([]*WeeklySt
 	}
 
 	var weeks [][]int
-	resp, err := s.client.Do(req, &weeks)
+	resp, err := s.client.Do(ctx, req, &weeks)
 
 	// convert int slices into WeeklyStats
 	var stats []*WeeklyStats
@@ -163,8 +164,8 @@ func (r RepositoryParticipation) String() string {
 // it is now computing the requested statistics. A follow up request, after a
 // delay of a second or so, should result in a successful request.
 //
-// GitHub API Docs: https://developer.github.com/v3/repos/statistics/#participation
-func (s *RepositoriesService) ListParticipation(owner, repo string) (*RepositoryParticipation, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statistics/#participation
+func (s *RepositoriesService) ListParticipation(ctx context.Context, owner, repo string) (*RepositoryParticipation, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/stats/participation", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -172,12 +173,12 @@ func (s *RepositoriesService) ListParticipation(owner, repo string) (*Repository
 	}
 
 	participation := new(RepositoryParticipation)
-	resp, err := s.client.Do(req, participation)
+	resp, err := s.client.Do(ctx, req, participation)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return participation, resp, err
+	return participation, resp, nil
 }
 
 // PunchCard represents the number of commits made during a given hour of a
@@ -196,8 +197,8 @@ type PunchCard struct {
 // it is now computing the requested statistics. A follow up request, after a
 // delay of a second or so, should result in a successful request.
 //
-// GitHub API Docs: https://developer.github.com/v3/repos/statistics/#punch-card
-func (s *RepositoriesService) ListPunchCard(owner, repo string) ([]*PunchCard, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statistics/#punch-card
+func (s *RepositoriesService) ListPunchCard(ctx context.Context, owner, repo string) ([]*PunchCard, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/stats/punch_card", owner, repo)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -205,7 +206,7 @@ func (s *RepositoriesService) ListPunchCard(owner, repo string) ([]*PunchCard, *
 	}
 
 	var results [][]int
-	resp, err := s.client.Do(req, &results)
+	resp, err := s.client.Do(ctx, req, &results)
 
 	// convert int slices into Punchcards
 	var cards []*PunchCard

vendor/github.com/google/go-github/github/repos_statuses.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -15,11 +16,11 @@ type RepoStatus struct {
 	ID  *int    `json:"id,omitempty"`
 	URL *string `json:"url,omitempty"`
 
-	// State is the current state of the repository.  Possible values are:
+	// State is the current state of the repository. Possible values are:
 	// pending, success, error, or failure.
 	State *string `json:"state,omitempty"`
 
-	// TargetURL is the URL of the page representing this status.  It will be
+	// TargetURL is the URL of the page representing this status. It will be
 	// linked from the GitHub UI to allow users to see the source of the status.
 	TargetURL *string `json:"target_url,omitempty"`
 
@@ -39,10 +40,10 @@ func (r RepoStatus) String() string {
 }
 
 // ListStatuses lists the statuses of a repository at the specified
-// reference.  ref can be a SHA, a branch name, or a tag name.
+// reference. ref can be a SHA, a branch name, or a tag name.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
-func (s *RepositoriesService) ListStatuses(owner, repo, ref string, opt *ListOptions) ([]*RepoStatus, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
+func (s *RepositoriesService) ListStatuses(ctx context.Context, owner, repo, ref string, opt *ListOptions) ([]*RepoStatus, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits/%v/statuses", owner, repo, ref)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -54,20 +55,20 @@ func (s *RepositoriesService) ListStatuses(owner, repo, ref string, opt *ListOpt
 		return nil, nil, err
 	}
 
-	statuses := new([]*RepoStatus)
-	resp, err := s.client.Do(req, statuses)
+	var statuses []*RepoStatus
+	resp, err := s.client.Do(ctx, req, &statuses)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *statuses, resp, err
+	return statuses, resp, nil
 }
 
 // CreateStatus creates a new status for a repository at the specified
-// reference.  Ref can be a SHA, a branch name, or a tag name.
+// reference. Ref can be a SHA, a branch name, or a tag name.
 //
-// GitHub API docs: http://developer.github.com/v3/repos/statuses/#create-a-status
-func (s *RepositoriesService) CreateStatus(owner, repo, ref string, status *RepoStatus) (*RepoStatus, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/repos/statuses/#create-a-status
+func (s *RepositoriesService) CreateStatus(ctx context.Context, owner, repo, ref string, status *RepoStatus) (*RepoStatus, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/statuses/%v", owner, repo, ref)
 	req, err := s.client.NewRequest("POST", u, status)
 	if err != nil {
@@ -75,17 +76,17 @@ func (s *RepositoriesService) CreateStatus(owner, repo, ref string, status *Repo
 	}
 
 	repoStatus := new(RepoStatus)
-	resp, err := s.client.Do(req, repoStatus)
+	resp, err := s.client.Do(ctx, req, repoStatus)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return repoStatus, resp, err
+	return repoStatus, resp, nil
 }
 
 // CombinedStatus represents the combined status of a repository at a particular reference.
 type CombinedStatus struct {
-	// State is the combined state of the repository.  Possible values are:
+	// State is the combined state of the repository. Possible values are:
 	// failure, pending, or success.
 	State *string `json:"state,omitempty"`
 
@@ -103,10 +104,10 @@ func (s CombinedStatus) String() string {
 }
 
 // GetCombinedStatus returns the combined status of a repository at the specified
-// reference.  ref can be a SHA, a branch name, or a tag name.
+// reference. ref can be a SHA, a branch name, or a tag name.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
-func (s *RepositoriesService) GetCombinedStatus(owner, repo, ref string, opt *ListOptions) (*CombinedStatus, *Response, error) {
+func (s *RepositoriesService) GetCombinedStatus(ctx context.Context, owner, repo, ref string, opt *ListOptions) (*CombinedStatus, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/commits/%v/status", owner, repo, ref)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -119,10 +120,10 @@ func (s *RepositoriesService) GetCombinedStatus(owner, repo, ref string, opt *Li
 	}
 
 	status := new(CombinedStatus)
-	resp, err := s.client.Do(req, status)
+	resp, err := s.client.Do(ctx, req, status)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return status, resp, err
+	return status, resp, nil
 }

vendor/github.com/google/go-github/github/repos_traffic.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // TrafficReferrer represent information about traffic from a referrer .
 type TrafficReferrer struct {
@@ -52,7 +55,7 @@ type TrafficBreakdownOptions struct {
 // ListTrafficReferrers list the top 10 referrers over the last 14 days.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/traffic/#list-referrers
-func (s *RepositoriesService) ListTrafficReferrers(owner, repo string) ([]*TrafficReferrer, *Response, error) {
+func (s *RepositoriesService) ListTrafficReferrers(ctx context.Context, owner, repo string) ([]*TrafficReferrer, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/traffic/popular/referrers", owner, repo)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -60,22 +63,19 @@ func (s *RepositoriesService) ListTrafficReferrers(owner, repo string) ([]*Traff
 		return nil, nil, err
 	}
 
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeTrafficPreview)
-
-	trafficReferrers := new([]*TrafficReferrer)
-	resp, err := s.client.Do(req, &trafficReferrers)
+	var trafficReferrers []*TrafficReferrer
+	resp, err := s.client.Do(ctx, req, &trafficReferrers)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *trafficReferrers, resp, err
+	return trafficReferrers, resp, nil
 }
 
 // ListTrafficPaths list the top 10 popular content over the last 14 days.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/traffic/#list-paths
-func (s *RepositoriesService) ListTrafficPaths(owner, repo string) ([]*TrafficPath, *Response, error) {
+func (s *RepositoriesService) ListTrafficPaths(ctx context.Context, owner, repo string) ([]*TrafficPath, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/traffic/popular/paths", owner, repo)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -83,22 +83,19 @@ func (s *RepositoriesService) ListTrafficPaths(owner, repo string) ([]*TrafficPa
 		return nil, nil, err
 	}
 
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeTrafficPreview)
-
-	var paths = new([]*TrafficPath)
-	resp, err := s.client.Do(req, &paths)
+	var paths []*TrafficPath
+	resp, err := s.client.Do(ctx, req, &paths)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *paths, resp, err
+	return paths, resp, nil
 }
 
 // ListTrafficViews get total number of views for the last 14 days and breaks it down either per day or week.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/traffic/#views
-func (s *RepositoriesService) ListTrafficViews(owner, repo string, opt *TrafficBreakdownOptions) (*TrafficViews, *Response, error) {
+func (s *RepositoriesService) ListTrafficViews(ctx context.Context, owner, repo string, opt *TrafficBreakdownOptions) (*TrafficViews, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/traffic/views", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -110,22 +107,19 @@ func (s *RepositoriesService) ListTrafficViews(owner, repo string, opt *TrafficB
 		return nil, nil, err
 	}
 
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeTrafficPreview)
-
 	trafficViews := new(TrafficViews)
-	resp, err := s.client.Do(req, &trafficViews)
+	resp, err := s.client.Do(ctx, req, &trafficViews)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return trafficViews, resp, err
+	return trafficViews, resp, nil
 }
 
 // ListTrafficClones get total number of clones for the last 14 days and breaks it down either per day or week for the last 14 days.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/traffic/#views
-func (s *RepositoriesService) ListTrafficClones(owner, repo string, opt *TrafficBreakdownOptions) (*TrafficClones, *Response, error) {
+func (s *RepositoriesService) ListTrafficClones(ctx context.Context, owner, repo string, opt *TrafficBreakdownOptions) (*TrafficClones, *Response, error) {
 	u := fmt.Sprintf("repos/%v/%v/traffic/clones", owner, repo)
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -137,14 +131,11 @@ func (s *RepositoriesService) ListTrafficClones(owner, repo string, opt *Traffic
 		return nil, nil, err
 	}
 
-	// TODO: remove custom Accept header when this API fully launches.
-	req.Header.Set("Accept", mediaTypeTrafficPreview)
-
 	trafficClones := new(TrafficClones)
-	resp, err := s.client.Do(req, &trafficClones)
+	resp, err := s.client.Do(ctx, req, &trafficClones)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return trafficClones, resp, err
+	return trafficClones, resp, nil
 }

vendor/github.com/google/go-github/github/search.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 
 	qs "github.com/google/go-querystring/query"
@@ -14,13 +15,14 @@ import (
 // SearchService provides access to the search related functions
 // in the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/search/
+// GitHub API docs: https://developer.github.com/v3/search/
 type SearchService service
 
 // SearchOptions specifies optional parameters to the SearchService methods.
 type SearchOptions struct {
-	// How to sort the search results.  Possible values are:
+	// How to sort the search results. Possible values are:
 	//   - for repositories: stars, fork, updated
+	//   - for commits: author-date, committer-date
 	//   - for code: indexed
 	//   - for issues: comments, created, updated
 	//   - for users: followers, repositories, joined
@@ -47,10 +49,41 @@ type RepositoriesSearchResult struct {
 
 // Repositories searches repositories via various criteria.
 //
-// GitHub API docs: http://developer.github.com/v3/search/#search-repositories
-func (s *SearchService) Repositories(query string, opt *SearchOptions) (*RepositoriesSearchResult, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/search/#search-repositories
+func (s *SearchService) Repositories(ctx context.Context, query string, opt *SearchOptions) (*RepositoriesSearchResult, *Response, error) {
 	result := new(RepositoriesSearchResult)
-	resp, err := s.search("repositories", query, opt, result)
+	resp, err := s.search(ctx, "repositories", query, opt, result)
+	return result, resp, err
+}
+
+// CommitsSearchResult represents the result of a commits search.
+type CommitsSearchResult struct {
+	Total             *int            `json:"total_count,omitempty"`
+	IncompleteResults *bool           `json:"incomplete_results,omitempty"`
+	Commits           []*CommitResult `json:"items,omitempty"`
+}
+
+// CommitResult represents a commit object as returned in commit search endpoint response.
+type CommitResult struct {
+	SHA         *string   `json:"sha,omitempty"`
+	Commit      *Commit   `json:"commit,omitempty"`
+	Author      *User     `json:"author,omitempty"`
+	Committer   *User     `json:"committer,omitempty"`
+	Parents     []*Commit `json:"parents,omitempty"`
+	HTMLURL     *string   `json:"html_url,omitempty"`
+	URL         *string   `json:"url,omitempty"`
+	CommentsURL *string   `json:"comments_url,omitempty"`
+
+	Repository *Repository `json:"repository,omitempty"`
+	Score      *float64    `json:"score,omitempty"`
+}
+
+// Commits searches commits via various criteria.
+//
+// GitHub API docs: https://developer.github.com/v3/search/#search-commits
+func (s *SearchService) Commits(ctx context.Context, query string, opt *SearchOptions) (*CommitsSearchResult, *Response, error) {
+	result := new(CommitsSearchResult)
+	resp, err := s.search(ctx, "commits", query, opt, result)
 	return result, resp, err
 }
 
@@ -63,10 +96,10 @@ type IssuesSearchResult struct {
 
 // Issues searches issues via various criteria.
 //
-// GitHub API docs: http://developer.github.com/v3/search/#search-issues
-func (s *SearchService) Issues(query string, opt *SearchOptions) (*IssuesSearchResult, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/search/#search-issues
+func (s *SearchService) Issues(ctx context.Context, query string, opt *SearchOptions) (*IssuesSearchResult, *Response, error) {
 	result := new(IssuesSearchResult)
-	resp, err := s.search("issues", query, opt, result)
+	resp, err := s.search(ctx, "issues", query, opt, result)
 	return result, resp, err
 }
 
@@ -79,10 +112,10 @@ type UsersSearchResult struct {
 
 // Users searches users via various criteria.
 //
-// GitHub API docs: http://developer.github.com/v3/search/#search-users
-func (s *SearchService) Users(query string, opt *SearchOptions) (*UsersSearchResult, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/search/#search-users
+func (s *SearchService) Users(ctx context.Context, query string, opt *SearchOptions) (*UsersSearchResult, *Response, error) {
 	result := new(UsersSearchResult)
-	resp, err := s.search("users", query, opt, result)
+	resp, err := s.search(ctx, "users", query, opt, result)
 	return result, resp, err
 }
 
@@ -128,21 +161,21 @@ func (c CodeResult) String() string {
 
 // Code searches code via various criteria.
 //
-// GitHub API docs: http://developer.github.com/v3/search/#search-code
-func (s *SearchService) Code(query string, opt *SearchOptions) (*CodeSearchResult, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/search/#search-code
+func (s *SearchService) Code(ctx context.Context, query string, opt *SearchOptions) (*CodeSearchResult, *Response, error) {
 	result := new(CodeSearchResult)
-	resp, err := s.search("code", query, opt, result)
+	resp, err := s.search(ctx, "code", query, opt, result)
 	return result, resp, err
 }
 
 // Helper function that executes search queries against different
-// GitHub search types (repositories, code, issues, users)
-func (s *SearchService) search(searchType string, query string, opt *SearchOptions, result interface{}) (*Response, error) {
+// GitHub search types (repositories, commits, code, issues, users)
+func (s *SearchService) search(ctx context.Context, searchType string, query string, opt *SearchOptions, result interface{}) (*Response, error) {
 	params, err := qs.Values(opt)
 	if err != nil {
 		return nil, err
 	}
-	params.Add("q", query)
+	params.Set("q", query)
 	u := fmt.Sprintf("search/%s?%s", searchType, params.Encode())
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -150,11 +183,16 @@ func (s *SearchService) search(searchType string, query string, opt *SearchOptio
 		return nil, err
 	}
 
-	if opt != nil && opt.TextMatch {
+	switch {
+	case searchType == "commits":
+		// Accept header for search commits preview endpoint
+		// TODO: remove custom Accept header when this API fully launches.
+		req.Header.Set("Accept", mediaTypeCommitSearchPreview)
+	case opt != nil && opt.TextMatch:
 		// Accept header defaults to "application/vnd.github.v3+json"
 		// We change it here to fetch back text-match metadata
 		req.Header.Set("Accept", "application/vnd.github.v3.text-match+json")
 	}
 
-	return s.client.Do(req, result)
+	return s.client.Do(ctx, req, result)
 }

vendor/github.com/google/go-github/github/strings.go

@@ -16,7 +16,7 @@ import (
 var timestampType = reflect.TypeOf(Timestamp{})
 
 // Stringify attempts to create a reasonable string representation of types in
-// the GitHub library.  It does things like resolve pointers to their values
+// the GitHub library. It does things like resolve pointers to their values
 // and omits struct fields with nil values.
 func Stringify(message interface{}) string {
 	var buf bytes.Buffer

vendor/github.com/google/go-github/github/users.go

@@ -5,12 +5,15 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // UsersService handles communication with the user related
 // methods of the GitHub API.
 //
-// GitHub API docs: http://developer.github.com/v3/users/
+// GitHub API docs: https://developer.github.com/v3/users/
 type UsersService service
 
 // User represents a GitHub user.
@@ -68,11 +71,11 @@ func (u User) String() string {
 	return Stringify(u)
 }
 
-// Get fetches a user.  Passing the empty string will fetch the authenticated
+// Get fetches a user. Passing the empty string will fetch the authenticated
 // user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/#get-a-single-user
-func (s *UsersService) Get(user string) (*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/#get-a-single-user
+func (s *UsersService) Get(ctx context.Context, user string) (*User, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v", user)
@@ -85,18 +88,18 @@ func (s *UsersService) Get(user string) (*User, *Response, error) {
 	}
 
 	uResp := new(User)
-	resp, err := s.client.Do(req, uResp)
+	resp, err := s.client.Do(ctx, req, uResp)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return uResp, resp, err
+	return uResp, resp, nil
 }
 
 // GetByID fetches a user.
 //
 // Note: GetByID uses the undocumented GitHub API endpoint /user/:id.
-func (s *UsersService) GetByID(id int) (*User, *Response, error) {
+func (s *UsersService) GetByID(ctx context.Context, id int) (*User, *Response, error) {
 	u := fmt.Sprintf("user/%d", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -104,18 +107,18 @@ func (s *UsersService) GetByID(id int) (*User, *Response, error) {
 	}
 
 	user := new(User)
-	resp, err := s.client.Do(req, user)
+	resp, err := s.client.Do(ctx, req, user)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return user, resp, err
+	return user, resp, nil
 }
 
 // Edit the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/#update-the-authenticated-user
-func (s *UsersService) Edit(user *User) (*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/#update-the-authenticated-user
+func (s *UsersService) Edit(ctx context.Context, user *User) (*User, *Response, error) {
 	u := "user"
 	req, err := s.client.NewRequest("PATCH", u, user)
 	if err != nil {
@@ -123,12 +126,12 @@ func (s *UsersService) Edit(user *User) (*User, *Response, error) {
 	}
 
 	uResp := new(User)
-	resp, err := s.client.Do(req, uResp)
+	resp, err := s.client.Do(ctx, req, uResp)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return uResp, resp, err
+	return uResp, resp, nil
 }
 
 // UserListOptions specifies optional parameters to the UsersService.ListAll
@@ -144,8 +147,8 @@ type UserListOptions struct {
 //
 // To paginate through all users, populate 'Since' with the ID of the last user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/#get-all-users
-func (s *UsersService) ListAll(opt *UserListOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/#get-all-users
+func (s *UsersService) ListAll(ctx context.Context, opt *UserListOptions) ([]*User, *Response, error) {
 	u, err := addOptions("users", opt)
 	if err != nil {
 		return nil, nil, err
@@ -156,20 +159,20 @@ func (s *UsersService) ListAll(opt *UserListOptions) ([]*User, *Response, error)
 		return nil, nil, err
 	}
 
-	users := new([]*User)
-	resp, err := s.client.Do(req, users)
+	var users []*User
+	resp, err := s.client.Do(ctx, req, &users)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *users, resp, err
+	return users, resp, nil
 }
 
 // ListInvitations lists all currently-open repository invitations for the
 // authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/invitations/#list-a-users-repository-invitations
-func (s *UsersService) ListInvitations() ([]*RepositoryInvitation, *Response, error) {
+func (s *UsersService) ListInvitations(ctx context.Context) ([]*RepositoryInvitation, *Response, error) {
 	req, err := s.client.NewRequest("GET", "user/repository_invitations", nil)
 	if err != nil {
 		return nil, nil, err
@@ -179,19 +182,19 @@ func (s *UsersService) ListInvitations() ([]*RepositoryInvitation, *Response, er
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
 	invites := []*RepositoryInvitation{}
-	resp, err := s.client.Do(req, &invites)
+	resp, err := s.client.Do(ctx, req, &invites)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return invites, resp, err
+	return invites, resp, nil
 }
 
 // AcceptInvitation accepts the currently-open repository invitation for the
 // authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/invitations/#accept-a-repository-invitation
-func (s *UsersService) AcceptInvitation(invitationID int) (*Response, error) {
+func (s *UsersService) AcceptInvitation(ctx context.Context, invitationID int) (*Response, error) {
 	u := fmt.Sprintf("user/repository_invitations/%v", invitationID)
 	req, err := s.client.NewRequest("PATCH", u, nil)
 	if err != nil {
@@ -201,14 +204,14 @@ func (s *UsersService) AcceptInvitation(invitationID int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // DeclineInvitation declines the currently-open repository invitation for the
 // authenticated user.
 //
 // GitHub API docs: https://developer.github.com/v3/repos/invitations/#decline-a-repository-invitation
-func (s *UsersService) DeclineInvitation(invitationID int) (*Response, error) {
+func (s *UsersService) DeclineInvitation(ctx context.Context, invitationID int) (*Response, error) {
 	u := fmt.Sprintf("user/repository_invitations/%v", invitationID)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -218,5 +221,5 @@ func (s *UsersService) DeclineInvitation(invitationID int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeRepositoryInvitationsPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/users_administration.go

@@ -5,12 +5,15 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // PromoteSiteAdmin promotes a user to a site administrator of a GitHub Enterprise instance.
 //
 // GitHub API docs: https://developer.github.com/v3/users/administration/#promote-an-ordinary-user-to-a-site-administrator
-func (s *UsersService) PromoteSiteAdmin(user string) (*Response, error) {
+func (s *UsersService) PromoteSiteAdmin(ctx context.Context, user string) (*Response, error) {
 	u := fmt.Sprintf("users/%v/site_admin", user)
 
 	req, err := s.client.NewRequest("PUT", u, nil)
@@ -18,13 +21,13 @@ func (s *UsersService) PromoteSiteAdmin(user string) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // DemoteSiteAdmin demotes a user from site administrator of a GitHub Enterprise instance.
 //
 // GitHub API docs: https://developer.github.com/v3/users/administration/#demote-a-site-administrator-to-an-ordinary-user
-func (s *UsersService) DemoteSiteAdmin(user string) (*Response, error) {
+func (s *UsersService) DemoteSiteAdmin(ctx context.Context, user string) (*Response, error) {
 	u := fmt.Sprintf("users/%v/site_admin", user)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -32,13 +35,13 @@ func (s *UsersService) DemoteSiteAdmin(user string) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Suspend a user on a GitHub Enterprise instance.
 //
 // GitHub API docs: https://developer.github.com/v3/users/administration/#suspend-a-user
-func (s *UsersService) Suspend(user string) (*Response, error) {
+func (s *UsersService) Suspend(ctx context.Context, user string) (*Response, error) {
 	u := fmt.Sprintf("users/%v/suspended", user)
 
 	req, err := s.client.NewRequest("PUT", u, nil)
@@ -46,13 +49,13 @@ func (s *UsersService) Suspend(user string) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Unsuspend a user on a GitHub Enterprise instance.
 //
 // GitHub API docs: https://developer.github.com/v3/users/administration/#unsuspend-a-user
-func (s *UsersService) Unsuspend(user string) (*Response, error) {
+func (s *UsersService) Unsuspend(ctx context.Context, user string) (*Response, error) {
 	u := fmt.Sprintf("users/%v/suspended", user)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -60,5 +63,5 @@ func (s *UsersService) Unsuspend(user string) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/users_blocking.go

@@ -0,0 +1,91 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListBlockedUsers lists all the blocked users by the authenticated user.
+//
+// GitHub API docs: https://developer.github.com/v3/users/blocking/#list-blocked-users
+func (s *UsersService) ListBlockedUsers(ctx context.Context, opt *ListOptions) ([]*User, *Response, error) {
+	u := "user/blocks"
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeBlockUsersPreview)
+
+	var blockedUsers []*User
+	resp, err := s.client.Do(ctx, req, &blockedUsers)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return blockedUsers, resp, nil
+}
+
+// IsBlocked reports whether specified user is blocked by the authenticated user.
+//
+// GitHub API docs: https://developer.github.com/v3/users/blocking/#check-whether-youve-blocked-a-user
+func (s *UsersService) IsBlocked(ctx context.Context, user string) (bool, *Response, error) {
+	u := fmt.Sprintf("user/blocks/%v", user)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return false, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeBlockUsersPreview)
+
+	resp, err := s.client.Do(ctx, req, nil)
+	isBlocked, err := parseBoolResponse(err)
+	return isBlocked, resp, err
+}
+
+// BlockUser blocks specified user for the authenticated user.
+//
+// GitHub API docs: https://developer.github.com/v3/users/blocking/#block-a-user
+func (s *UsersService) BlockUser(ctx context.Context, user string) (*Response, error) {
+	u := fmt.Sprintf("user/blocks/%v", user)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeBlockUsersPreview)
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// UnblockUser unblocks specified user for the authenticated user.
+//
+// GitHub API docs: https://developer.github.com/v3/users/blocking/#unblock-a-user
+func (s *UsersService) UnblockUser(ctx context.Context, user string) (*Response, error) {
+	u := fmt.Sprintf("user/blocks/%v", user)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeBlockUsersPreview)
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/github/users_emails.go

@@ -5,6 +5,8 @@
 
 package github
 
+import "context"
+
 // UserEmail represents user's email address
 type UserEmail struct {
 	Email    *string `json:"email,omitempty"`
@@ -14,8 +16,8 @@ type UserEmail struct {
 
 // ListEmails lists all email addresses for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user
-func (s *UsersService) ListEmails(opt *ListOptions) ([]*UserEmail, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user
+func (s *UsersService) ListEmails(ctx context.Context, opt *ListOptions) ([]*UserEmail, *Response, error) {
 	u := "user/emails"
 	u, err := addOptions(u, opt)
 	if err != nil {
@@ -27,43 +29,43 @@ func (s *UsersService) ListEmails(opt *ListOptions) ([]*UserEmail, *Response, er
 		return nil, nil, err
 	}
 
-	emails := new([]*UserEmail)
-	resp, err := s.client.Do(req, emails)
+	var emails []*UserEmail
+	resp, err := s.client.Do(ctx, req, &emails)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *emails, resp, err
+	return emails, resp, nil
 }
 
 // AddEmails adds email addresses of the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/emails/#add-email-addresses
-func (s *UsersService) AddEmails(emails []string) ([]*UserEmail, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/emails/#add-email-addresses
+func (s *UsersService) AddEmails(ctx context.Context, emails []string) ([]*UserEmail, *Response, error) {
 	u := "user/emails"
 	req, err := s.client.NewRequest("POST", u, emails)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	e := new([]*UserEmail)
-	resp, err := s.client.Do(req, e)
+	var e []*UserEmail
+	resp, err := s.client.Do(ctx, req, &e)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *e, resp, err
+	return e, resp, nil
 }
 
 // DeleteEmails deletes email addresses from authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/emails/#delete-email-addresses
-func (s *UsersService) DeleteEmails(emails []string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/emails/#delete-email-addresses
+func (s *UsersService) DeleteEmails(ctx context.Context, emails []string) (*Response, error) {
 	u := "user/emails"
 	req, err := s.client.NewRequest("DELETE", u, emails)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/users_followers.go

@@ -5,13 +5,16 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
-// ListFollowers lists the followers for a user.  Passing the empty string will
+// ListFollowers lists the followers for a user. Passing the empty string will
 // fetch followers for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/followers/#list-followers-of-a-user
-func (s *UsersService) ListFollowers(user string, opt *ListOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/followers/#list-followers-of-a-user
+func (s *UsersService) ListFollowers(ctx context.Context, user string, opt *ListOptions) ([]*User, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/followers", user)
@@ -28,20 +31,20 @@ func (s *UsersService) ListFollowers(user string, opt *ListOptions) ([]*User, *R
 		return nil, nil, err
 	}
 
-	users := new([]*User)
-	resp, err := s.client.Do(req, users)
+	var users []*User
+	resp, err := s.client.Do(ctx, req, &users)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *users, resp, err
+	return users, resp, nil
 }
 
-// ListFollowing lists the people that a user is following.  Passing the empty
+// ListFollowing lists the people that a user is following. Passing the empty
 // string will list people the authenticated user is following.
 //
-// GitHub API docs: http://developer.github.com/v3/users/followers/#list-users-followed-by-another-user
-func (s *UsersService) ListFollowing(user string, opt *ListOptions) ([]*User, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/followers/#list-users-followed-by-another-user
+func (s *UsersService) ListFollowing(ctx context.Context, user string, opt *ListOptions) ([]*User, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/following", user)
@@ -58,20 +61,20 @@ func (s *UsersService) ListFollowing(user string, opt *ListOptions) ([]*User, *R
 		return nil, nil, err
 	}
 
-	users := new([]*User)
-	resp, err := s.client.Do(req, users)
+	var users []*User
+	resp, err := s.client.Do(ctx, req, &users)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *users, resp, err
+	return users, resp, nil
 }
 
-// IsFollowing checks if "user" is following "target".  Passing the empty
+// IsFollowing checks if "user" is following "target". Passing the empty
 // string for "user" will check if the authenticated user is following "target".
 //
-// GitHub API docs: http://developer.github.com/v3/users/followers/#check-if-you-are-following-a-user
-func (s *UsersService) IsFollowing(user, target string) (bool, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/followers/#check-if-you-are-following-a-user
+func (s *UsersService) IsFollowing(ctx context.Context, user, target string) (bool, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/following/%v", user, target)
@@ -84,33 +87,33 @@ func (s *UsersService) IsFollowing(user, target string) (bool, *Response, error)
 		return false, nil, err
 	}
 
-	resp, err := s.client.Do(req, nil)
+	resp, err := s.client.Do(ctx, req, nil)
 	following, err := parseBoolResponse(err)
 	return following, resp, err
 }
 
 // Follow will cause the authenticated user to follow the specified user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/followers/#follow-a-user
-func (s *UsersService) Follow(user string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/followers/#follow-a-user
+func (s *UsersService) Follow(ctx context.Context, user string) (*Response, error) {
 	u := fmt.Sprintf("user/following/%v", user)
 	req, err := s.client.NewRequest("PUT", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }
 
 // Unfollow will cause the authenticated user to unfollow the specified user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/followers/#unfollow-a-user
-func (s *UsersService) Unfollow(user string) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/followers/#unfollow-a-user
+func (s *UsersService) Unfollow(ctx context.Context, user string) (*Response, error) {
 	u := fmt.Sprintf("user/following/%v", user)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/users_gpg_keys.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"context"
 	"fmt"
 	"time"
 )
@@ -39,12 +40,24 @@ type GPGEmail struct {
 	Verified *bool   `json:"verified,omitempty"`
 }
 
-// ListGPGKeys lists the current user's GPG keys. It requires authentication
+// ListGPGKeys lists the public GPG keys for a user. Passing the empty
+// string will fetch keys for the authenticated user. It requires authentication
 // via Basic Auth or via OAuth with at least read:gpg_key scope.
-//
-// GitHub API docs: https://developer.github.com/v3/users/gpg_keys/#list-your-gpg-keys
-func (s *UsersService) ListGPGKeys() ([]*GPGKey, *Response, error) {
-	req, err := s.client.NewRequest("GET", "user/gpg_keys", nil)
+
+// GitHub API docs: https://developer.github.com/v3/users/gpg_keys/#list-gpg-keys-for-a-user
+func (s *UsersService) ListGPGKeys(ctx context.Context, user string, opt *ListOptions) ([]*GPGKey, *Response, error) {
+	var u string
+	if user != "" {
+		u = fmt.Sprintf("users/%v/gpg_keys", user)
+	} else {
+		u = "user/gpg_keys"
+	}
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -53,19 +66,19 @@ func (s *UsersService) ListGPGKeys() ([]*GPGKey, *Response, error) {
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
 	var keys []*GPGKey
-	resp, err := s.client.Do(req, &keys)
+	resp, err := s.client.Do(ctx, req, &keys)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return keys, resp, err
+	return keys, resp, nil
 }
 
 // GetGPGKey gets extended details for a single GPG key. It requires authentication
 // via Basic Auth or via OAuth with at least read:gpg_key scope.
 //
 // GitHub API docs: https://developer.github.com/v3/users/gpg_keys/#get-a-single-gpg-key
-func (s *UsersService) GetGPGKey(id int) (*GPGKey, *Response, error) {
+func (s *UsersService) GetGPGKey(ctx context.Context, id int) (*GPGKey, *Response, error) {
 	u := fmt.Sprintf("user/gpg_keys/%v", id)
 	req, err := s.client.NewRequest("GET", u, nil)
 	if err != nil {
@@ -76,19 +89,19 @@ func (s *UsersService) GetGPGKey(id int) (*GPGKey, *Response, error) {
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
 	key := &GPGKey{}
-	resp, err := s.client.Do(req, key)
+	resp, err := s.client.Do(ctx, req, key)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return key, resp, err
+	return key, resp, nil
 }
 
 // CreateGPGKey creates a GPG key. It requires authenticatation via Basic Auth
 // or OAuth with at least write:gpg_key scope.
 //
 // GitHub API docs: https://developer.github.com/v3/users/gpg_keys/#create-a-gpg-key
-func (s *UsersService) CreateGPGKey(armoredPublicKey string) (*GPGKey, *Response, error) {
+func (s *UsersService) CreateGPGKey(ctx context.Context, armoredPublicKey string) (*GPGKey, *Response, error) {
 	gpgKey := &struct {
 		ArmoredPublicKey string `json:"armored_public_key"`
 	}{ArmoredPublicKey: armoredPublicKey}
@@ -101,19 +114,19 @@ func (s *UsersService) CreateGPGKey(armoredPublicKey string) (*GPGKey, *Response
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
 	key := &GPGKey{}
-	resp, err := s.client.Do(req, key)
+	resp, err := s.client.Do(ctx, req, key)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return key, resp, err
+	return key, resp, nil
 }
 
 // DeleteGPGKey deletes a GPG key. It requires authentication via Basic Auth or
 // via OAuth with at least admin:gpg_key scope.
 //
 // GitHub API docs: https://developer.github.com/v3/users/gpg_keys/#delete-a-gpg-key
-func (s *UsersService) DeleteGPGKey(id int) (*Response, error) {
+func (s *UsersService) DeleteGPGKey(ctx context.Context, id int) (*Response, error) {
 	u := fmt.Sprintf("user/gpg_keys/%v", id)
 	req, err := s.client.NewRequest("DELETE", u, nil)
 	if err != nil {
@@ -123,5 +136,5 @@ func (s *UsersService) DeleteGPGKey(id int) (*Response, error) {
 	// TODO: remove custom Accept header when this API fully launches.
 	req.Header.Set("Accept", mediaTypeGitSigningPreview)
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/users_keys.go

@@ -5,7 +5,10 @@
 
 package github
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 // Key represents a public SSH key used to authenticate a user or deploy script.
 type Key struct {
@@ -20,11 +23,11 @@ func (k Key) String() string {
 	return Stringify(k)
 }
 
-// ListKeys lists the verified public keys for a user.  Passing the empty
+// ListKeys lists the verified public keys for a user. Passing the empty
 // string will fetch keys for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/keys/#list-public-keys-for-a-user
-func (s *UsersService) ListKeys(user string, opt *ListOptions) ([]*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/keys/#list-public-keys-for-a-user
+func (s *UsersService) ListKeys(ctx context.Context, user string, opt *ListOptions) ([]*Key, *Response, error) {
 	var u string
 	if user != "" {
 		u = fmt.Sprintf("users/%v/keys", user)
@@ -41,19 +44,19 @@ func (s *UsersService) ListKeys(user string, opt *ListOptions) ([]*Key, *Respons
 		return nil, nil, err
 	}
 
-	keys := new([]*Key)
-	resp, err := s.client.Do(req, keys)
+	var keys []*Key
+	resp, err := s.client.Do(ctx, req, &keys)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return *keys, resp, err
+	return keys, resp, nil
 }
 
 // GetKey fetches a single public key.
 //
-// GitHub API docs: http://developer.github.com/v3/users/keys/#get-a-single-public-key
-func (s *UsersService) GetKey(id int) (*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/keys/#get-a-single-public-key
+func (s *UsersService) GetKey(ctx context.Context, id int) (*Key, *Response, error) {
 	u := fmt.Sprintf("user/keys/%v", id)
 
 	req, err := s.client.NewRequest("GET", u, nil)
@@ -62,18 +65,18 @@ func (s *UsersService) GetKey(id int) (*Key, *Response, error) {
 	}
 
 	key := new(Key)
-	resp, err := s.client.Do(req, key)
+	resp, err := s.client.Do(ctx, req, key)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return key, resp, err
+	return key, resp, nil
 }
 
 // CreateKey adds a public key for the authenticated user.
 //
-// GitHub API docs: http://developer.github.com/v3/users/keys/#create-a-public-key
-func (s *UsersService) CreateKey(key *Key) (*Key, *Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/keys/#create-a-public-key
+func (s *UsersService) CreateKey(ctx context.Context, key *Key) (*Key, *Response, error) {
 	u := "user/keys"
 
 	req, err := s.client.NewRequest("POST", u, key)
@@ -82,18 +85,18 @@ func (s *UsersService) CreateKey(key *Key) (*Key, *Response, error) {
 	}
 
 	k := new(Key)
-	resp, err := s.client.Do(req, k)
+	resp, err := s.client.Do(ctx, req, k)
 	if err != nil {
 		return nil, resp, err
 	}
 
-	return k, resp, err
+	return k, resp, nil
 }
 
 // DeleteKey deletes a public key.
 //
-// GitHub API docs: http://developer.github.com/v3/users/keys/#delete-a-public-key
-func (s *UsersService) DeleteKey(id int) (*Response, error) {
+// GitHub API docs: https://developer.github.com/v3/users/keys/#delete-a-public-key
+func (s *UsersService) DeleteKey(ctx context.Context, id int) (*Response, error) {
 	u := fmt.Sprintf("user/keys/%v", id)
 
 	req, err := s.client.NewRequest("DELETE", u, nil)
@@ -101,5 +104,5 @@ func (s *UsersService) DeleteKey(id int) (*Response, error) {
 		return nil, err
 	}
 
-	return s.client.Do(req, nil)
+	return s.client.Do(ctx, req, nil)
 }

vendor/github.com/google/go-github/github/with_appengine.go

@@ -0,0 +1,26 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+// This file provides glue for making github work on App Engine.
+// In order to get the entire github package to compile with
+// Go 1.6, you will need to rewrite all the import "context" lines.
+// Fortunately, this is easy with "gofmt":
+//
+//     gofmt -w -r '"context" -> "golang.org/x/net/context"' *.go
+
+package github
+
+import (
+	"context"
+	"net/http"
+
+	"google.golang.org/appengine"
+)
+
+func withContext(ctx context.Context, req *http.Request) (context.Context, *http.Request) {
+	return appengine.WithContext(ctx, req), req
+}

vendor/github.com/google/go-github/github/without_appengine.go

@@ -0,0 +1,19 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+// This file provides glue for making github work without App Engine.
+
+package github
+
+import (
+	"context"
+	"net/http"
+)
+
+func withContext(ctx context.Context, req *http.Request) (context.Context, *http.Request) {
+	return ctx, req.WithContext(ctx)
+}