func (c *Client) FollowProject(account, repo string) (*Project, error) {
	project := &Project{}
	err := c.request("POST", fmt.Sprintf("project/%s/%s/follow", account, repo), project, nil, nil)
	if err != nil {
		return nil, err
	}
	if err := cleanupProject(project); err != nil {
		return nil, err
	}
	return project, nil
}
FollowProject follows a project
package circleci
import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"strconv"
	"time"
)
const (
	queryLimit = 100  
)
var (
	defaultBaseURL = &url.URL{Host: "circleci.com", Scheme: "https", Path: "/api/v1/"}
	defaultLogger  = log.New(os.Stderr, "", log.LstdFlags)
)
type Logger interface {
	Printf(fmt string, args ...interface{})
}
type APIError struct {
	HTTPStatusCode int
	Message        string
}
func (e *APIError) Error() string {
	return fmt.Sprintf("%d: %s", e.HTTPStatusCode, e.Message)
}
type Client struct {
	BaseURL    *url.URL      
	Token      string        
	HTTPClient *http.Client  
	Debug  bool    
	Logger Logger  
}
func (c *Client) baseURL() *url.URL {
	if c.BaseURL == nil {
		return defaultBaseURL
	}
	return c.BaseURL
}
func (c *Client) client() *http.Client {
	if c.HTTPClient == nil {
		return http.DefaultClient
	}
	return c.HTTPClient
}
func (c *Client) logger() Logger {
	if c.Logger == nil {
		return defaultLogger
	}
	return c.Logger
}
func (c *Client) debug(format string, args ...interface{}) {
	if c.Debug {
		c.logger().Printf(format, args...)
	}
}
func (c *Client) debugRequest(req *http.Request) {
	if c.Debug {
		out, err := httputil.DumpRequestOut(req, true)
		if err != nil {
			c.debug("error debugging request %+v: %s", req, err)
		}
		c.debug("request:\n%+v", string(out))
	}
}
func (c *Client) debugResponse(resp *http.Response) {
	if c.Debug {
		out, err := httputil.DumpResponse(resp, true)
		if err != nil {
			c.debug("error debugging response %+v: %s", resp, err)
		}
		c.debug("response:\n%+v", string(out))
	}
}
type nopCloser struct {
	io.Reader
}
func (n nopCloser) Close() error { return nil }
func (c *Client) request(method, path string, responseStruct interface{}, params url.Values, bodyStruct interface{}) error {
	if params == nil {
		params = url.Values{}
	}
	params.Set("circle-token", c.Token)
	u := c.baseURL().ResolveReference(&url.URL{Path: path, RawQuery: params.Encode()})
	c.debug("building request for %s", u)
	req, err := http.NewRequest(method, u.String(), nil)
	if err != nil {
		return err
	}
	if bodyStruct != nil {
		b, err := json.Marshal(bodyStruct)
		if err != nil {
			return err
		}
		req.Body = nopCloser{bytes.NewBuffer(b)}
	}
	req.Header.Add("Accept", "application/json")
	req.Header.Add("Content-Type", "application/json")
	c.debugRequest(req)
	resp, err := c.client().Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	c.debugResponse(resp)
	if resp.StatusCode >= 300 {
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return &APIError{HTTPStatusCode: resp.StatusCode, Message: "unable to parse response: %s"}
		}
		if len(body) > 0 {
			message := struct {
				Message string `json:"message"`
			}{}
			err = json.Unmarshal(body, &message)
			if err != nil {
				return &APIError{
					HTTPStatusCode: resp.StatusCode,
					Message:        fmt.Sprintf("unable to parse API response: %s", err),
				}
			}
			return &APIError{HTTPStatusCode: resp.StatusCode, Message: message.Message}
		}
		return &APIError{HTTPStatusCode: resp.StatusCode}
	}
	if responseStruct != nil {
		err = json.NewDecoder(resp.Body).Decode(responseStruct)
		if err != nil {
			return err
		}
	}
	return nil
}
func (c *Client) Me() (*User, error) {
	user := &User{}
	err := c.request("GET", "me", user, nil, nil)
	if err != nil {
		return nil, err
	}
	return user, nil
}
func (c *Client) ListProjects() ([]*Project, error) {
	projects := []*Project{}
	err := c.request("GET", "projects", &projects, nil, nil)
	if err != nil {
		return nil, err
	}
	for _, project := range projects {
		if err := cleanupProject(project); err != nil {
			return nil, err
		}
	}
	return projects, nil
}
func (c *Client) EnableProject(account, repo string) error {
	return c.request("POST", fmt.Sprintf("project/%s/%s/enable", account, repo), nil, nil, nil)
}
func (c *Client) DisableProject(account, repo string) error {
	return c.request("DELETE", fmt.Sprintf("project/%s/%s/enable", account, repo), nil, nil, nil)
}