gohttp.go

package gohttp

import (
	"bytes"
	"encoding/json"
	"io"
	"net/http"
	"path/filepath"
	"strings"

	"github.com/google/go-querystring/query"
)

const (
	contentType     = "Content-Type"
	jsonContentType = "application/json"
	formContentType = "application/x-www-form-urlencoded"
)

// Client is the main struct that wraps net/http
type Client struct {
	c *http.Client

	// request parameters
	query        map[string]string
	queryStructs []interface{}
	headers      map[string]string
	url          string
	path         string
	body         io.Reader
}

// DefaultClient provides a simple usable client, it is given for quick usage.
// For more control, please create a client manually.
var DefaultClient = New()

// New returns a new GoClient with default values
func New() *Client {
	return &Client{
		c:            &http.Client{},
		query:        make(map[string]string),
		queryStructs: make([]interface{}, 5),
		headers:      make(map[string]string),
	}
}

func (c *Client) prepareRequest(method string) (*http.Request, error) {
	req, err := http.NewRequest(method, c.url, c.body)

	// concatenate path to url if exists
	if c.path != "" {
		p := req.URL.Path
		req.URL.Path = filepath.Join(p, c.path)
	}

	// setup the query string, there can be many query strings,
	// and they're connected with `&` symbol. Also rawquery and
	// queryStructs data will be merged.
	if len(c.query) != 0 {
		q := req.URL.Query()
		for key, value := range c.query {
			q.Add(key, value)
		}
		req.URL.RawQuery = q.Encode()
	}

	if len(c.queryStructs) != 0 {
		q := req.URL.Query()

		for _, queryStruct := range c.queryStructs {
			qValues, err := query.Values(queryStruct)
			if err != nil {
				return req, err
			}
			for key, values := range qValues {
				for _, value := range values {
					q.Add(key, value)
				}
			}
		}
		req.URL.RawQuery = q.Encode()
	}

	// setup headers
	if len(c.headers) != 0 {
		for key, value := range c.headers {
			req.Header.Add(key, value)
		}
	}

	if err != nil {
		return nil, err
	}

	return req, nil
}

// Do takes HTTP and url, then makes the request, return the response
func (c *Client) Do(method, url string) (*http.Response, error) {
	c.url = url
	req, err := c.prepareRequest(method)
	if err != nil {
		return nil, err
	}
	return c.c.Do(req)
}

// Get handles HTTP GET request, and return response to user
func (c *Client) Get(url string) (*http.Response, error) {
	return c.Do("GET", url)
}

// Post handles HTTP POST request
func (c *Client) Post(url string) (*http.Response, error) {
	return c.Do("POST", url)
}

// Head handles HTTP HEAD request
func (c *Client) Head(url string) (*http.Response, error) {
	return c.Do("HEAD", url)
}

// Put handles HTTP PUT request
func (c *Client) Put(url string) (*http.Response, error) {
	return c.Do("PUT", url)
}

// Delete handles HTTP DELETE request
func (c *Client) Delete(url string) (*http.Response, error) {
	return c.Do("DELETE", url)
}

// Patch handles HTTP PATCH request
func (c *Client) Patch(url string) (*http.Response, error) {
	return c.Do("PATCH", url)
}

// Options handles HTTP OPTIONS request
func (c *Client) Options(url string) (*http.Response, error) {
	return c.Do("OPTIONS", url)
}

// Path concatenates base url with resource path.
// Path can be with or without slash `/` at both end,
// it will be handled properly.
func (c *Client) Path(paths ...string) *Client {
	for _, path := range paths {
		if path != "" {
			c.path = filepath.Join(c.path, path)
		}
	}
	return c
}

// Query set parameter query string
func (c *Client) Query(key, value string) *Client {
	c.query[key] = value
	return c
}

// QueryStruct parses a struct as query strings
// On how it works, please refer to github.com/google/go-querystring repo
func (c *Client) QueryStruct(queryStruct interface{}) *Client {
	c.queryStructs = append(c.queryStructs, queryStruct)
	return c
}

// Header sets request header data
func (c *Client) Header(key, value string) *Client {
	c.headers[key] = value
	return c
}

type jsonBodyData struct {
	payload interface{}
}

func (jbd jsonBodyData) Body() (io.Reader, error) {
	buf := &bytes.Buffer{}
	err := json.NewEncoder(buf).Encode(jbd.payload)
	if err != nil {
		return nil, err
	}
	return buf, nil
}

// JSON accepts a struct as data, and sets it as body, and send it as application/json
// If the actual method does not support body or json data, such as `GET`, `HEAD`,
// it will be simply omitted.
func (c *Client) JSON(bodyJSON interface{}) *Client {
	if bodyJSON != nil {
		c.Header(contentType, jsonContentType)
		//TODO: how to handle error
		body, _ := jsonBodyData{payload: bodyJSON}.Body()
		c.body = body
	}
	return c
}

type formBodyData struct {
	payload interface{}
}

// Body returns io.Reader from form data.
// Form data is a collection of many key-value pairs,
// so we use go-querystring to parse it to string, then
// create a io.Reader interface.
func (fbd formBodyData) Body() (io.Reader, error) {
	values, err := query.Values(fbd.payload)
	if err != nil {
		return nil, err
	}
	return strings.NewReader(values.Encode()), nil
}

// Form accepts a struct, uses it as body data, and sent it as application/www-x-form-urlencoded
// If the actual method does not support body or form data, such as `GET`, `HEAD`,
// it will be simply omitted.
func (c *Client) Form(bodyForm interface{}) *Client {
	if bodyForm != nil {
		c.Header(contentType, formContentType)
		body, _ := formBodyData{payload: bodyForm}.Body()
		c.body = body
	}
	return c
}

// Body accepts `io.Reader`, will read data from it and use it as request body.
// This doee not set `Content-Type` header, so users should use `Header(key, value)`
// to specify it if necessary.
func (c *Client) Body(body io.Reader) *Client {
	if body != nil {
		c.body = body
	}
	return c
}

// Get provides a shortcut to send `GET` request
func Get(url string) (*http.Response, error) {
	return DefaultClient.Get(url)
}

// Head provides a shortcut to send `HEAD` request
func Head(url string) (*http.Response, error) {
	return DefaultClient.Head(url)
}

// Delete provides a shortcut to send `DELETE` request
func Delete(url string) (*http.Response, error) {
	return DefaultClient.Delete(url)
}

// Options provides a shortcut to send `OPTIONS` request
func Options(url string) (*http.Response, error) {
	return DefaultClient.Options(url)
}

// Post provides a shortcut to send `POST` request
func Post(url string, data io.Reader) (*http.Response, error) {
	return DefaultClient.Body(data).Post(url)
}

// Put provides a shortcut to send `PUT` request
func Put(url string, data io.Reader) (*http.Response, error) {
	return DefaultClient.Body(data).Put(url)
}

// Patch provides a shortcut to send `PATCH` request
func Patch(url string, data io.Reader) (*http.Response, error) {
	return DefaultClient.Body(data).Patch(url)
}