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, includeQueryParams bool, maxMemory int64, v interface{}) (err error)
• func DecodeForm(r *http.Request, includeQueryParams bool, v interface{}) (err error)
• func DecodeJSON(r *http.Request, includeQueryParams bool, maxMemory int64, v interface{}) (err error)
• func DecodeMultipartForm(r *http.Request, includeQueryParams bool, maxMemory int64, v interface{}) (err error)
• func DecodeQueryParams(r *http.Request, includeSEOQueryParams bool, v interface{}) (err error)
• func DecodeSEOQueryParams(r *http.Request, v interface{}) (err error)
• func DecodeXML(r *http.Request, includeQueryParams 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{}) error
• func JSONBytes(w http.ResponseWriter, status int, b []byte) (err error)
• func JSONP(w http.ResponseWriter, status int, i interface{}, callback string) error
• func ParseForm(r *http.Request) error
• func ParseMultipartForm(r *http.Request, maxMemory int64) error
• func QueryParams(r *http.Request, includeSEOQueryParams bool) (values url.Values)
• func XML(w http.ResponseWriter, status int, i interface{}) 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) IRouteGroup
• func (g *Mux) GroupWithMore(prefix string, middleware ...Middleware) IRouteGroup
• func (g *Mux) GroupWithNone(prefix string) 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 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, includeQueryParams 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 includeQueryParams=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 or added to parsed JSON or XML; in short SEO query params are treated just like normal query params.

func DecodeForm ¶

func DecodeForm(r *http.Request, includeQueryParams bool, v interface{}) (err error)

DecodeForm parses the requests form data into the provided struct.

The Content-Type and http method are not checked.

NOTE: when includeQueryParams=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 DecodeJSON ¶

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

DecodeJSON decodes the request body into the provided struct and limits the request size via an io.LimitReader using the maxMemory param.

The Content-Type e.g. "application/json" and http method are not checked.

NOTE: when includeQueryParams=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 parsed JSON; in short SEO query params are treated just like normal query params.

func DecodeMultipartForm ¶

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

DecodeMultipartForm parses the requests form data into the provided struct.

The Content-Type and http method are not checked.

NOTE: when includeQueryParams=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 DecodeQueryParams ¶

func DecodeQueryParams(r *http.Request, includeSEOQueryParams bool, v interface{}) (err error)

DecodeQueryParams takes the URL Query params, adds SEO params or not based on the includeSEOQueryParams flag.

NOTE: DecodeQueryParams is also used/called from Decode when no ContentType is specified the only difference is that it will always pass true for includeSEOQueryParams

func DecodeSEOQueryParams ¶

func DecodeSEOQueryParams(r *http.Request, v interface{}) (err error)

DecodeSEOQueryParams decodes the SEO Query params only and ignores the normal URL Query params.

func DecodeXML ¶

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

DecodeXML decodes the request body into the provided struct and limits the request size via an io.LimitReader using the maxMemory param.

The Content-Type e.g. "application/xml" and http method are not checked.

NOTE: when includeQueryParams=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 parsed XML; 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{}) 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) 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 QueryParams ¶

func QueryParams(r *http.Request, includeSEOQueryParams bool) (values url.Values)

QueryParams returns the r.URL.Query() values and optionally have them include the SEO query params eg. route /users/:id?test=val if includeSEOQueryParams=true then values will include 'id' and 'test' values

func XML ¶

func XML(w http.ResponseWriter, status int, i interface{}) 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
	GroupWithNone(prefix string) IRouteGroup
	GroupWithMore(prefix string, middleware ...Middleware) IRouteGroup
	Group(prefix string) 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) IRouteGroup

Group creates a new sub router with specified prefix and retains existing middleware.

func (*Mux) GroupWithMore ¶

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

GroupWithMore creates a new sub router with specified prefix, retains existing middleware and adds new middleware.

func (*Mux) GroupWithNone ¶

func (g *Mux) GroupWithNone(prefix string) IRouteGroup

GroupWithNone creates a new sub router with specified prefix and no middleware attached.

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 ReqVars ¶

type ReqVars interface {
	URLParam(pname string) string
}

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 ¶