package pure

import "github.com/go-playground/pure"

Index ¶

• Constants
• func AcceptedLanguages(r *http.Request) (languages []string)
• func Attachment(w http.ResponseWriter, r io.Reader, filename string) (err error)
• func ClientIP(r *http.Request) (clientIP string)
• func Decode(r *http.Request, includeFormQueryParams bool, maxMemory int64, v interface{}) (err error)
• func Inline(w http.ResponseWriter, r io.Reader, filename string) (err error)
• func JSON(w http.ResponseWriter, status int, i interface{}) (err error)
• func JSONBytes(w http.ResponseWriter, status int, b []byte) (err error)
• func JSONP(w http.ResponseWriter, status int, i interface{}, callback string) (err error)
• func ParseForm(r *http.Request) error
• func ParseMultipartForm(r *http.Request, maxMemory int64) error
• func XML(w http.ResponseWriter, status int, i interface{}) (err error)
• func XMLBytes(w http.ResponseWriter, status int, b []byte) (err error)
• type FormDecoder
• type IRouteGroup
• type IRoutes
• type Middleware
• type Mux
• func New() *Mux
• func (g *Mux) Any(path string, h http.HandlerFunc)
• func (g *Mux) Connect(path string, h http.HandlerFunc)
• func (g *Mux) Delete(path string, h http.HandlerFunc)
• func (g *Mux) Get(path string, h http.HandlerFunc)
• func (g *Mux) Group(prefix string, middleware ...Middleware) IRouteGroup
• func (g *Mux) Handle(method string, path string, h http.HandlerFunc)
• func (g *Mux) Head(path string, h http.HandlerFunc)
• func (g *Mux) Match(methods []string, path string, h http.HandlerFunc)
• func (g *Mux) Options(path string, h http.HandlerFunc)
• func (g *Mux) Patch(path string, h http.HandlerFunc)
• func (g *Mux) Post(path string, h http.HandlerFunc)
• func (g *Mux) Put(path string, h http.HandlerFunc)
• func (p *Mux) Register404(notFound http.HandlerFunc, middleware ...Middleware)
• func (p *Mux) RegisterAutomaticOPTIONS(middleware ...Middleware)
• func (p *Mux) RegisterMethodNotAllowed(middleware ...Middleware)
• func (p *Mux) Serve() http.Handler
• func (p *Mux) SetRedirectTrailingSlash(set bool)
• func (g *Mux) Trace(path string, h http.HandlerFunc)
• func (g *Mux) Use(m ...Middleware)
• type Param
• type Params
• func (p Params) Get(key string) (param string)
• type ReqVars
• func RequestVars(r *http.Request) ReqVars

Constants ¶

const (
	ApplicationJSON                  = "application/json"
	ApplicationJSONCharsetUTF8       = ApplicationJSON + "; " + CharsetUTF8
	ApplicationJavaScript            = "application/javascript"
	ApplicationJavaScriptCharsetUTF8 = ApplicationJavaScript + "; " + CharsetUTF8
	ApplicationXML                   = "application/xml"
	ApplicationXMLCharsetUTF8        = ApplicationXML + "; " + CharsetUTF8
	ApplicationForm                  = "application/x-www-form-urlencoded"
	ApplicationQueryParams           = ""
	ApplicationProtobuf              = "application/protobuf"
	ApplicationMsgpack               = "application/msgpack"
	TextHTML                         = "text/html"
	TextHTMLCharsetUTF8              = TextHTML + "; " + CharsetUTF8
	TextPlain                        = "text/plain"
	TextPlainCharsetUTF8             = TextPlain + "; " + CharsetUTF8
	MultipartForm                    = "multipart/form-data"
	OctetStream                      = "application/octet-stream"

	CharsetUTF8 = "charset=utf-8"

	AcceptedLanguage   = "Accept-Language"
	AcceptEncoding     = "Accept-Encoding"
	Authorization      = "Authorization"
	ContentDisposition = "Content-Disposition"
	ContentEncoding    = "Content-Encoding"
	ContentLength      = "Content-Length"
	ContentType        = "Content-Type"
	Location           = "Location"
	Upgrade            = "Upgrade"
	Vary               = "Vary"
	WWWAuthenticate    = "WWW-Authenticate"
	XForwardedFor      = "X-Forwarded-For"
	XRealIP            = "X-Real-Ip"
	Allow              = "Allow"
	Origin             = "Origin"

	Gzip = "gzip"

	WildcardParam = "*wildcard"
)

HTTP Constant Terms and Variables

Functions ¶

func AcceptedLanguages ¶

func AcceptedLanguages(r *http.Request) (languages []string)

AcceptedLanguages returns an array of accepted languages denoted by the Accept-Language header sent by the browser NOTE: some stupid browsers send in locales lowercase when all the rest send it properly

func Attachment ¶

func Attachment(w http.ResponseWriter, r io.Reader, filename string) (err error)

Attachment is a helper method for returning an attachement file to be downloaded, if you with to open inline see function Inline

func ClientIP ¶

func ClientIP(r *http.Request) (clientIP string)

ClientIP implements a best effort algorithm to return the real client IP, it parses X-Real-IP and X-Forwarded-For in order to work properly with reverse-proxies such us: nginx or haproxy.

func Decode ¶

func Decode(r *http.Request, includeFormQueryParams bool, maxMemory int64, v interface{}) (err error)

Decode takes the request and attempts to discover it's content type via the http headers and then decode the request body into the provided struct. Example if header was "application/json" would decode using json.NewDecoder(io.LimitReader(r.Body, maxMemory)).Decode(v).

NOTE: when includeFormQueryParams=true both query params and SEO query params will be parsed and included eg. route /user/:id?test=true both 'id' and 'test' are treated as query params and added to the request.Form prior to decoding; in short SEO query params are treated just like normal query params.

func Inline ¶

func Inline(w http.ResponseWriter, r io.Reader, filename string) (err error)

Inline is a helper method for returning a file inline to be rendered/opened by the browser

func JSON ¶

func JSON(w http.ResponseWriter, status int, i interface{}) (err error)

JSON marshals provided interface + returns JSON + status code

func JSONBytes ¶

func JSONBytes(w http.ResponseWriter, status int, b []byte) (err error)

JSONBytes returns provided JSON response with status code

func JSONP ¶

func JSONP(w http.ResponseWriter, status int, i interface{}, callback string) (err error)

JSONP sends a JSONP response with status code and uses `callback` to construct the JSONP payload.

func ParseForm ¶

func ParseForm(r *http.Request) error

ParseForm calls the underlying http.Request ParseForm but also adds the URL params to the request Form as if they were defined as query params i.e. ?id=13&ok=true but does not add the params to the http.Request.URL.RawQuery for SEO purposes

func ParseMultipartForm ¶

func ParseMultipartForm(r *http.Request, maxMemory int64) error

ParseMultipartForm calls the underlying http.Request ParseMultipartForm but also adds the URL params to the request Form as if they were defined as query params i.e. ?id=13&ok=true but does not add the params to the http.Request.URL.RawQuery for SEO purposes

func XML ¶

func XML(w http.ResponseWriter, status int, i interface{}) (err error)

XML marshals provided interface + returns XML + status code

func XMLBytes ¶

func XMLBytes(w http.ResponseWriter, status int, b []byte) (err error)

XMLBytes returns provided XML response with status code

Types ¶

type FormDecoder ¶

type FormDecoder interface {
	Decode(interface{}, url.Values) error
}

FormDecoder is the type used for decoding a form for use

var (
	// DefaultDecoder is pure's default form decoder
	DefaultDecoder FormDecoder = form.NewDecoder()
)

type IRouteGroup ¶

type IRouteGroup interface {
	IRoutes
	Group(prefix string, middleware ...Middleware) IRouteGroup
}

IRouteGroup interface for router group

type IRoutes ¶

type IRoutes interface {
	Use(...Middleware)
	Any(string, http.HandlerFunc)
	Get(string, http.HandlerFunc)
	Post(string, http.HandlerFunc)
	Delete(string, http.HandlerFunc)
	Patch(string, http.HandlerFunc)
	Put(string, http.HandlerFunc)
	Options(string, http.HandlerFunc)
	Head(string, http.HandlerFunc)
	Connect(string, http.HandlerFunc)
	Trace(string, http.HandlerFunc)
}

IRoutes interface for routes

type Middleware ¶

type Middleware func(h http.HandlerFunc) http.HandlerFunc

Middleware is pure's middleware definition

type Mux ¶

type Mux struct {
	// contains filtered or unexported fields
}

Mux is the main request multiplexer

func New ¶

func New() *Mux

New Creates and returns a new Pure instance

func (*Mux) Any ¶

func (g *Mux) Any(path string, h http.HandlerFunc)

Any adds a route & handler to the router for all HTTP methods.

func (*Mux) Connect ¶

func (g *Mux) Connect(path string, h http.HandlerFunc)

Connect adds a CONNECT route & handler to the router.

func (*Mux) Delete ¶

func (g *Mux) Delete(path string, h http.HandlerFunc)

Delete adds a DELETE route & handler to the router.

func (*Mux) Get ¶

func (g *Mux) Get(path string, h http.HandlerFunc)

Get adds a GET route & handler to the router.

func (*Mux) Group ¶

func (g *Mux) Group(prefix string, middleware ...Middleware) IRouteGroup

Group creates a new sub router with prefix. It inherits all properties from the parent. Passing middleware overrides parent middleware but still keeps the root level middleware intact.

func (*Mux) Handle ¶

func (g *Mux) Handle(method string, path string, h http.HandlerFunc)

Handle allows for any method to be registered with the given route & handler. Allows for non standard methods to be used like CalDavs PROPFIND and so forth.

func (*Mux) Head ¶

func (g *Mux) Head(path string, h http.HandlerFunc)

Head adds a HEAD route & handler to the router.

func (*Mux) Match ¶

func (g *Mux) Match(methods []string, path string, h http.HandlerFunc)

Match adds a route & handler to the router for multiple HTTP methods provided.

func (*Mux) Options ¶

func (g *Mux) Options(path string, h http.HandlerFunc)

Options adds an OPTIONS route & handler to the router.

func (*Mux) Patch ¶

func (g *Mux) Patch(path string, h http.HandlerFunc)

Patch adds a PATCH route & handler to the router.

func (*Mux) Post ¶

func (g *Mux) Post(path string, h http.HandlerFunc)

Post adds a POST route & handler to the router.

func (*Mux) Put ¶

func (g *Mux) Put(path string, h http.HandlerFunc)

Put adds a PUT route & handler to the router.

func (*Mux) Register404 ¶

func (p *Mux) Register404(notFound http.HandlerFunc, middleware ...Middleware)

Register404 alows for overriding of the not found handler function. NOTE: this is run after not finding a route even after redirecting with the trailing slash

func (*Mux) RegisterAutomaticOPTIONS ¶

func (p *Mux) RegisterAutomaticOPTIONS(middleware ...Middleware)

RegisterAutomaticOPTIONS tells pure whether to automatically handle OPTION requests; manually configured OPTION handlers take precedence. default true

func (*Mux) RegisterMethodNotAllowed ¶

func (p *Mux) RegisterMethodNotAllowed(middleware ...Middleware)

RegisterMethodNotAllowed tells pure whether to handle the http 405 Method Not Allowed status code

func (*Mux) Serve ¶

func (p *Mux) Serve() http.Handler

Serve returns an http.Handler to be used.

func (*Mux) SetRedirectTrailingSlash ¶

func (p *Mux) SetRedirectTrailingSlash(set bool)

SetRedirectTrailingSlash tells pure whether to try and fix a URL by trying to find it lowercase -> with or without slash -> 404

func (*Mux) Trace ¶

func (g *Mux) Trace(path string, h http.HandlerFunc)

Trace adds a TRACE route & handler to the router.

func (*Mux) Use ¶

func (g *Mux) Use(m ...Middleware)

Use adds a middleware handler to the group middleware chain.

type Param ¶

type Param struct {
	Key   string
	Value string
}

Param is a single URL parameter, consisting of a key and a value.

type Params ¶

type Params []Param

Params is a Param-slice, as returned by the router. The slice is ordered, the first URL parameter is also the first slice value. It is therefore safe to read values by the index.

func (Params) Get ¶

func (p Params) Get(key string) (param string)

Get returns the URL parameter for the given key, or blank if not found

type ReqVars ¶

type ReqVars interface {
	URLParam(pname string) string
	QueryParams() url.Values
}

ReqVars is the interface of request scoped variables tracked by pure

func RequestVars ¶

func RequestVars(r *http.Request) ReqVars

RequestVars returns the request scoped variables tracked by pure

Source Files ¶

constants.go form_decoder.go group.go helpers.go node.go pure.go request_vars.go util.go

Directories ¶