[WIP] Implement event activity API

octokit/activity_events.go

@@ -0,0 +1,73 @@
+package octokit
+
+import (
+	"time"
+)
+
+var (
+	PublicEventsURL = Hyperlink("/events")
+)
+
+func (c *Client) ActivityEvents() *ActivityEventsService {
+	return &ActivityEventsService{client: c}
+}
+
+// ActivityEventsService is a service providing access to event activity
+type ActivityEventsService struct {
+	client *Client
+}
+
+func (r *ActivityEventsService) One(uri *Hyperlink, params M) (event *Event,
+	result *Result) {
+	if uri == nil {
+		uri = &PublicEventsURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return nil, &Result{Err: err}
+	}
+	result = r.client.get(url, &event)
+	return
+}
+
+// All gets a list of all events associated with the url of the service
+func (r *ActivityEventsService) All(uri *Hyperlink, params M) (
+	events []Event, result *Result) {
+	if uri == nil {
+		uri = &PublicEventsURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return nil, &Result{Err: err}
+	}
+	result = r.client.get(url, &events)
+	return
+}
+
+type Actor struct {
+	ID         int    `json:"id,omitempty"`
+	Login      string `json:"login,omitempty"`
+	GravatarID string `json:"gravatar_id,omitempty"`
+	URL        string `json:"url,omitempty"`
+	AvatarURL  string `json:"avatar_url,omitempty"`
+}
+
+type Payload struct {
+	PushID       int      `json:"push_id,omitempty"`
+	Size         int      `json:"size,omitempty"`
+	DistinctSize int      `json:"distinct_size,omitempty"`
+	Ref          string   `json:"ref,omitempty"`
+	Head         string   `json:"head,omitempty"`
+	Before       string   `json:"before,omitempty"`
+	Commits      []Commit `json:"commits,omitempty"`
+}
+
+type Event struct {
+	ID        string     `json:"id,omitempty"`
+	Type      string     `json:"type,omitempty"`
+	Actor     Actor      `json:"actor,omitempty"`
+	Repo      Repository `json:"repo,omitempty"`
+	Payload   Payload    `json:"payload,omitempty"`
+	Public    bool       `json:"public,omitempty"`
+	CreatedAt *time.Time `json:"created_at,omitempty"`
+}

octokit/issues.go

@@ -1,49 +1,78 @@
 package octokit
 
 import (
-	"net/url"
-	"time"
-
 	"github.com/jingweno/go-sawyer/hypermedia"
+	"time"
 )
 
 // RepoIssuesURL is a template for accessing issues in a particular
 // repository for a particular owner that can be expanded to a full address.
-var RepoIssuesURL = Hyperlink("repos/{owner}/{repo}/issues{/number}")
+var RepoIssuesURL = Hyperlink("repos/{owner}/{repo}/issues{/number}{?filter,state,labels,sort}")
 
 // Issues creates an IssuesService with a base url
-func (c *Client) Issues(url *url.URL) (issues *IssuesService) {
-	issues = &IssuesService{client: c, URL: url}
+func (c *Client) Issues() (issues *IssuesService) {
+	issues = &IssuesService{client: c}
 	return
 }
 
 // IssuesService is a service providing access to issues from a particular url
 type IssuesService struct {
 	client *Client
-	URL    *url.URL
 }
 
 // One gets a specific issue based on the url of the service
-func (i *IssuesService) One() (issue *Issue, result *Result) {
-	result = i.client.get(i.URL, &issue)
+func (i *IssuesService) One(uri *Hyperlink, params M) (issue *Issue,
+	result *Result) {
+	if uri == nil {
+		uri = &RepoIssuesURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return nil, &Result{Err: err}
+	}
+	result = i.client.get(url, &issue)
 	return
 }
 
 // All gets a list of all issues associated with the url of the service
-func (i *IssuesService) All() (issues []Issue, result *Result) {
-	result = i.client.get(i.URL, &issues)
+func (i *IssuesService) All(uri *Hyperlink, uriParams M) (issues []Issue,
+	result *Result) {
+	if uri == nil {
+		uri = &RepoIssuesURL
+	}
+	url, err := uri.Expand(uriParams)
+	if err != nil {
+		return nil, &Result{Err: err}
+	}
+	result = i.client.get(url, &issues)
 	return
 }
 
 // Create posts a new issue with particular parameters to the issues service url
-func (i *IssuesService) Create(params interface{}) (issue *Issue, result *Result) {
-	result = i.client.post(i.URL, params, &issue)
+func (i *IssuesService) Create(uri *Hyperlink, uriParams M,
+	params interface{}) (issue *Issue, result *Result) {
+	if uri == nil {
+		uri = &RepoIssuesURL
+	}
+	url, err := uri.Expand(uriParams)
+	if err != nil {
+		return nil, &Result{Err: err}
+	}
+	result = i.client.post(url, params, &issue)
 	return
 }
 
 // Update modifies a specific issue given parameters on the service url
-func (i *IssuesService) Update(params interface{}) (issue *Issue, result *Result) {
-	result = i.client.patch(i.URL, params, &issue)
+func (i *IssuesService) Update(uri *Hyperlink, uriParams M,
+	params interface{}) (issue *Issue, result *Result) {
+	if uri == nil {
+		uri = &RepoIssuesURL
+	}
+	url, err := uri.Expand(uriParams)
+	if err != nil {
+		return nil, &Result{Err: err}
+	}
+	result = i.client.patch(url, params, &issue)
 	return
 }
 

octokit/issues_test.go

@@ -14,10 +14,8 @@ func TestIssuesService_All(t *testing.T) {
 
 	stubGet(t, "/repos/octocat/Hello-World/issues", "issues", nil)
 
-	url, err := RepoIssuesURL.Expand(M{"owner": "octocat", "repo": "Hello-World"})
-	assert.NoError(t, err)
-
-	issues, result := client.Issues(url).All()
+	issues, result := client.Issues().All(nil, M{"owner": "octocat",
+		"repo": "Hello-World"})
 	assert.False(t, result.HasError())
 	assert.Len(t, issues, 1)
 
@@ -31,10 +29,8 @@ func TestIssuesService_One(t *testing.T) {
 
 	stubGet(t, "/repos/octocat/Hello-World/issues/1347", "issue", nil)
 
-	url, err := RepoIssuesURL.Expand(M{"owner": "octocat", "repo": "Hello-World", "number": 1347})
-	assert.NoError(t, err)
-
-	issue, result := client.Issues(url).One()
+	issue, result := client.Issues().One(nil, M{"owner": "octocat",
+		"repo": "Hello-World", "number": 1347})
 
 	assert.False(t, result.HasError())
 	validateIssue(t, *issue)
@@ -44,20 +40,19 @@ func TestIssuesService_Create(t *testing.T) {
 	setup()
 	defer tearDown()
 
-	mux.HandleFunc("/repos/octocat/Hello-World/issues", func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc("/repos/octocat/Hello-World/issues", func(
+		w http.ResponseWriter, r *http.Request) {
 		testMethod(t, r, "POST")
 		testBody(t, r, "{\"title\":\"title\",\"body\":\"body\"}\n")
 		respondWithJSON(w, loadFixture("issue.json"))
 	})
 
-	url, err := RepoIssuesURL.Expand(M{"owner": "octocat", "repo": "Hello-World"})
-	assert.NoError(t, err)
-
 	params := IssueParams{
 		Title: "title",
 		Body:  "body",
 	}
-	issue, result := client.Issues(url).Create(params)
+	issue, result := client.Issues().Create(nil, M{"owner": "octocat",
+		"repo": "Hello-World"}, params)
 
 	assert.False(t, result.HasError())
 	validateIssue(t, *issue)
@@ -67,20 +62,19 @@ func TestIssuesService_Update(t *testing.T) {
 	setup()
 	defer tearDown()
 
-	mux.HandleFunc("/repos/octocat/Hello-World/issues/1347", func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc("/repos/octocat/Hello-World/issues/1347", func(
+		w http.ResponseWriter, r *http.Request) {
 		testMethod(t, r, "PATCH")
 		testBody(t, r, "{\"title\":\"title\",\"body\":\"body\"}\n")
 		respondWithJSON(w, loadFixture("issue.json"))
 	})
 
-	url, err := RepoIssuesURL.Expand(M{"owner": "octocat", "repo": "Hello-World", "number": 1347})
-	assert.NoError(t, err)
-
 	params := IssueParams{
 		Title: "title",
 		Body:  "body",
 	}
-	issue, result := client.Issues(url).Update(params)
+	issue, result := client.Issues().Update(nil, M{"owner": "octocat",
+		"repo": "Hello-World", "number": 1347}, params)
 
 	assert.False(t, result.HasError())
 	validateIssue(t, *issue)

octokit/search.go

@@ -2,47 +2,77 @@ package octokit
 
 import (
 	"github.com/jingweno/go-sawyer/hypermedia"
-	"net/url"
 )
 
-var SearchURL = Hyperlink("search{/type}?q={query}{&page,per_page,sort,order}")
+var (
+	CodeSearchURL       = Hyperlink("/search/code?q={query}{&page,per_page,sort,order}")
+	IssueSearchURL      = Hyperlink("/search/issues?q={query}{&page,per_page,sort,order}")
+	RepositorySearchURL = Hyperlink("/search/repositories?q={query}{&page,per_page,sort,order}")
+	UserSearchURL       = Hyperlink("/search/users?q={query}{&page,per_page,sort,order}")
+)
 
-func (c *Client) Search(url *url.URL) (searches *SearchService) {
-	searches = &SearchService{client: c, URL: url}
-	return
+func (c *Client) Search() *SearchService {
+	return &SearchService{client: c}
 }
 
 // A service to return search records
 type SearchService struct {
 	client *Client
-	URL    *url.URL
 }
 
 // Get the user search results based on SearchService#URL
-func (g *SearchService) Users() (userSearchResults UserSearchResults,
-	result *Result) {
-	result = g.client.get(g.URL, &userSearchResults)
+func (g *SearchService) Users(uri *Hyperlink, params M) (
+	userSearchResults UserSearchResults, result *Result) {
+	if uri == nil {
+		uri = &UserSearchURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return UserSearchResults{}, &Result{Err: err}
+	}
+	result = g.client.get(url, &userSearchResults)
 	return
 }
 
 // Get the issue search results based on SearchService#URL
-func (g *SearchService) Issues() (issueSearchResults IssueSearchResults,
-	result *Result) {
-	result = g.client.get(g.URL, &issueSearchResults)
+func (g *SearchService) Issues(uri *Hyperlink, params M) (
+	issueSearchResults IssueSearchResults, result *Result) {
+	if uri == nil {
+		uri = &IssueSearchURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return IssueSearchResults{}, &Result{Err: err}
+	}
+	result = g.client.get(url, &issueSearchResults)
 	return
 }
 
 // Get the repository search results based on SearchService#URL
-func (g *SearchService) Repositories() (
+func (g *SearchService) Repositories(uri *Hyperlink, params M) (
 	repositorySearchResults RepositorySearchResults, result *Result) {
-	result = g.client.get(g.URL, &repositorySearchResults)
+	if uri == nil {
+		uri = &RepositorySearchURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return RepositorySearchResults{}, &Result{Err: err}
+	}
+	result = g.client.get(url, &repositorySearchResults)
 	return
 }
 
 // Get the code search results based on SearchService#URL
-func (g *SearchService) Code() (
+func (g *SearchService) Code(uri *Hyperlink, params M) (
 	codeSearchResults CodeSearchResults, result *Result) {
-	result = g.client.get(g.URL, &codeSearchResults)
+	if uri == nil {
+		uri = &CodeSearchURL
+	}
+	url, err := uri.Expand(params)
+	if err != nil {
+		return CodeSearchResults{}, &Result{Err: err}
+	}
+	result = g.client.get(url, &codeSearchResults)
 	return
 }
 

octokit/search_test.go

@@ -12,12 +12,7 @@ func TestSearchService_Users(t *testing.T) {
 
 	stubGet(t, "/search/users", "user_search", nil)
 
-	url, err := SearchURL.Expand(map[string]interface{}{
-		"type":  "users",
-		"query": "dhruvsinghal"})
-	assert.NoError(t, err)
-
-	searchResults, result := client.Search(url).Users()
+	searchResults, result := client.Search().Users(nil, M{"query": "dhruvsinghal"})
 
 	assert.False(t, result.HasError())
 	assert.False(t, searchResults.IncompleteResults)
@@ -35,12 +30,7 @@ func TestSearchService_Issues(t *testing.T) {
 
 	stubGet(t, "/search/issues", "issue_search", nil)
 
-	url, err := SearchURL.Expand(map[string]interface{}{
-		"type":  "issues",
-		"query": "color"})
-	assert.NoError(t, err)
-
-	searchResults, result := client.Search(url).Issues()
+	searchResults, result := client.Search().Issues(nil, M{"query": "color"})
 
 	assert.False(t, result.HasError())
 	assert.False(t, searchResults.IncompleteResults)
@@ -57,12 +47,8 @@ func TestSearchService_Repositories(t *testing.T) {
 
 	stubGet(t, "/search/repositories", "repository_search", nil)
 
-	url, err := SearchURL.Expand(map[string]interface{}{
-		"type":  "repositories",
-		"query": "asdfghjk"})
-	assert.NoError(t, err)
-
-	searchResults, result := client.Search(url).Repositories()
+	searchResults, result := client.Search().Repositories(nil,
+		M{"query": "asdfghjk"})
 
 	assert.False(t, result.HasError())
 	assert.False(t, searchResults.IncompleteResults)
@@ -80,12 +66,8 @@ func TestSearchService_Code(t *testing.T) {
 
 	stubGet(t, "/search/code", "code_search", nil)
 
-	url, err := SearchURL.Expand(map[string]interface{}{
-		"type":  "code",
+	searchResults, result := client.Search().Code(nil, M{
 		"query": "addClass in:file language:js repo:jquery/jquery"})
-	assert.NoError(t, err)
-
-	searchResults, result := client.Search(url).Code()
 
 	assert.False(t, result.HasError())
 	assert.False(t, searchResults.IncompleteResults)