GitHub Workflow Status codecov GoDoc Sourcegraph

Macaron Logo

Package macaron is a high productive and modular web framework in Go.

Getting Started

The minimum requirement of Go is 1.6.

To install Macaron:

go get

The very basic usage of Macaron:

package main

import ""

func main() {
	m := macaron.Classic()
	m.Get("/", func() string {
		return "Hello world!"


  • Powerful routing with suburl.
  • Flexible routes combinations.
  • Unlimited nested group routers.
  • Directly integrate with existing services.
  • Dynamically change template files at runtime.
  • Allow to use in-memory template and static files.
  • Easy to plugin/unplugin features with modular design.
  • Handy dependency injection powered by inject.
  • Better router layer and less reflection make faster speed.


Middlewares allow you easily plugin/unplugin features for your Macaron applications.

There are already many middlewares to simplify your work:

  • render - Go template engine
  • static - Serves static files
  • gzip - Gzip compression to all responses
  • binding - Request data binding and validation
  • i18n - Internationalization and Localization
  • cache - Cache manager
  • session - Session manager
  • csrf - Generates and validates csrf tokens
  • captcha - Captcha service
  • pongo2 - Pongo2 template engine support
  • sockets - WebSockets channels binding
  • bindata - Embed binary data as static and template files
  • toolbox - Health check, pprof, profile and statistic services
  • oauth2 - OAuth 2.0 backend
  • authz - ACL/RBAC/ABAC authorization based on Casbin
  • switcher - Multiple-site support
  • method - HTTP method override
  • permissions2 - Cookies, users and permissions
  • renders - Beego-like render engine(Macaron has built-in template engine, this is another option)
  • piwik - Server-side piwik analytics

Use Cases

  • Gogs: A painless self-hosted Git Service
  • Grafana: The open platform for beautiful analytics and monitoring
  • Peach: A modern web documentation server
  • Go Walker: Go online API documentation
  • Switch: Gopm registry
  • Critical Stack Intel: A 100% free intel marketplace from Critical Stack, Inc.

Getting Help



This project is under the Apache License, Version 2.0. See the LICENSE file for the full license text.

Expand ▾ Collapse ▴



    Package macaron is a high productive and modular web framework in Go.



    View Source
    const (
    	DEV  = "development"
    	PROD = "production"
    	TEST = "test"
    View Source
    const (


    View Source
    var (
    	ColorLog      = true
    	LogTimeFormat = "2006-01-02 15:04:05"
    View Source
    var (
    	// Env is the environment that Macaron is executing in.
    	// The MACARON_ENV is read on initialization to set this variable.
    	Env = DEV
    	// Path of work directory.
    	// You must set this value yourself
    	Root string
    	// Flash applies to current request.
    	FlashNow bool
    View Source
    var MaxMemory = int64(1024 * 1024 * 10)

      Maximum amount of memory to use when parsing a multipart form. Set this to whatever value you prefer; default is 10 MB.


      func Config

      func Config() *ini.File

        Config returns configuration convention object. It returns an empty object if there is no one available.

        func GenerateETag

        func GenerateETag(fileSize, fileName, modTime string) string

          GenerateETag generates an ETag based on size, filename and file modification time

          func GetDefaultListenInfo

          func GetDefaultListenInfo() (string, int)

          func GetExt

          func GetExt(s string) string

          func MatchTest

          func MatchTest(pattern, url string) bool

            MatchTest returns true if given URL is matched by given pattern.

            func NewRouteMap

            func NewRouteMap() *routeMap

              NewRouteMap initializes and returns a new routeMap.

              func ParseTplSet

              func ParseTplSet(tplSet string) (tplName string, tplDir string)

              func PathUnescape

              func PathUnescape(s string) (string, error)

                PathUnescape unescapes a path.

                func PrepareCharset

                func PrepareCharset(charset string) string

                func SetConfig

                func SetConfig(source interface{}, others ...interface{}) (_ *ini.File, err error)

                  SetConfig sets data sources for configuration.

                  func Version

                  func Version() string


                  type BeforeFunc

                  type BeforeFunc func(ResponseWriter)

                    BeforeFunc is a function that is called before the ResponseWriter has been written to.

                    type BeforeHandler

                    type BeforeHandler func(rw http.ResponseWriter, req *http.Request) bool

                      BeforeHandler represents a handler executes at beginning of every request. Macaron stops future process when it returns true.

                      type ComboRouter

                      type ComboRouter struct {
                      	// contains filtered or unexported fields

                        ComboRouter represents a combo router.

                        func (*ComboRouter) Delete

                        func (cr *ComboRouter) Delete(h ...Handler) *ComboRouter

                        func (*ComboRouter) Get

                        func (cr *ComboRouter) Get(h ...Handler) *ComboRouter

                        func (*ComboRouter) Head

                        func (cr *ComboRouter) Head(h ...Handler) *ComboRouter

                        func (*ComboRouter) Name

                        func (cr *ComboRouter) Name(name string)

                          Name sets name of ComboRouter route.

                          func (*ComboRouter) Options

                          func (cr *ComboRouter) Options(h ...Handler) *ComboRouter

                          func (*ComboRouter) Patch

                          func (cr *ComboRouter) Patch(h ...Handler) *ComboRouter

                          func (*ComboRouter) Post

                          func (cr *ComboRouter) Post(h ...Handler) *ComboRouter

                          func (*ComboRouter) Put

                          func (cr *ComboRouter) Put(h ...Handler) *ComboRouter

                          type Context

                          type Context struct {
                          	Req  Request
                          	Resp ResponseWriter
                          	Data map[string]interface{}
                          	// contains filtered or unexported fields

                            Context represents the runtime context of current request of Macaron instance. It is the integration of most frequently used middlewares and helper methods.

                            func (*Context) AllParams

                            func (ctx *Context) AllParams() Params

                              AllParams returns all params.

                              func (*Context) ChangeStaticPath

                              func (ctx *Context) ChangeStaticPath(oldPath, newPath string)

                                ChangeStaticPath changes static path from old to new one.

                                func (*Context) GetCookie

                                func (ctx *Context) GetCookie(name string) string

                                  GetCookie returns given cookie value from request header.

                                  func (*Context) GetCookieFloat64

                                  func (ctx *Context) GetCookieFloat64(name string) float64

                                    GetCookieFloat64 returns cookie result in float64 type.

                                    func (*Context) GetCookieInt

                                    func (ctx *Context) GetCookieInt(name string) int

                                      GetCookieInt returns cookie result in int type.

                                      func (*Context) GetCookieInt64

                                      func (ctx *Context) GetCookieInt64(name string) int64

                                        GetCookieInt64 returns cookie result in int64 type.

                                        func (*Context) GetFile

                                        func (ctx *Context) GetFile(name string) (multipart.File, *multipart.FileHeader, error)

                                          GetFile returns information about user upload file by given form field name.

                                          func (*Context) GetSecureCookie

                                          func (ctx *Context) GetSecureCookie(key string) (string, bool)

                                            GetSecureCookie returns given cookie value from request header with default secret string.

                                            func (*Context) GetSuperSecureCookie

                                            func (ctx *Context) GetSuperSecureCookie(secret, name string) (string, bool)

                                              GetSuperSecureCookie returns given cookie value from request header with secret string.

                                              func (*Context) HTML

                                              func (ctx *Context) HTML(status int, name string, data ...interface{})

                                                HTML renders the HTML with default template set.

                                                func (*Context) HTMLSet

                                                func (ctx *Context) HTMLSet(status int, setName, tplName string, data ...interface{})

                                                  HTMLSet renders the HTML with given template set name.

                                                  func (*Context) Next

                                                  func (c *Context) Next()

                                                  func (*Context) Params

                                                  func (ctx *Context) Params(name string) string

                                                    Params returns value of given param name. e.g. ctx.Params(":uid") or ctx.Params("uid")

                                                    func (*Context) ParamsEscape

                                                    func (ctx *Context) ParamsEscape(name string) string

                                                      ParamsEscape returns escapred params result. e.g. ctx.ParamsEscape(":uname")

                                                      func (*Context) ParamsFloat64

                                                      func (ctx *Context) ParamsFloat64(name string) float64

                                                        ParamsFloat64 returns params result in int64 type. e.g. ctx.ParamsFloat64(":uid")

                                                        func (*Context) ParamsInt

                                                        func (ctx *Context) ParamsInt(name string) int

                                                          ParamsInt returns params result in int type. e.g. ctx.ParamsInt(":uid")

                                                          func (*Context) ParamsInt64

                                                          func (ctx *Context) ParamsInt64(name string) int64

                                                            ParamsInt64 returns params result in int64 type. e.g. ctx.ParamsInt64(":uid")

                                                            func (*Context) Query

                                                            func (ctx *Context) Query(name string) string

                                                              Query querys form parameter.

                                                              func (*Context) QueryBool

                                                              func (ctx *Context) QueryBool(name string) bool

                                                                QueryBool returns query result in bool type.

                                                                func (*Context) QueryEscape

                                                                func (ctx *Context) QueryEscape(name string) string

                                                                  QueryEscape returns escapred query result.

                                                                  func (*Context) QueryFloat64

                                                                  func (ctx *Context) QueryFloat64(name string) float64

                                                                    QueryFloat64 returns query result in float64 type.

                                                                    func (*Context) QueryInt

                                                                    func (ctx *Context) QueryInt(name string) int

                                                                      QueryInt returns query result in int type.

                                                                      func (*Context) QueryInt64

                                                                      func (ctx *Context) QueryInt64(name string) int64

                                                                        QueryInt64 returns query result in int64 type.

                                                                        func (*Context) QueryStrings

                                                                        func (ctx *Context) QueryStrings(name string) []string

                                                                          QueryStrings returns a list of results by given query name.

                                                                          func (*Context) QueryTrim

                                                                          func (ctx *Context) QueryTrim(name string) string

                                                                            QueryTrim querys and trims spaces form parameter.

                                                                            func (*Context) Redirect

                                                                            func (ctx *Context) Redirect(location string, status

                                                                            func (*Context) RemoteAddr

                                                                            func (ctx *Context) RemoteAddr() string

                                                                              RemoteAddr returns more real IP address.

                                                                              func (*Context) ReplaceAllParams

                                                                              func (ctx *Context) ReplaceAllParams(params Params)

                                                                                ReplaceAllParams replace all current params with given params

                                                                                func (*Context) SaveToFile

                                                                                func (ctx *Context) SaveToFile(name, savePath string) error

                                                                                  SaveToFile reads a file from request by field name and saves to given path.

                                                                                  func (*Context) ServeContent

                                                                                  func (ctx *Context) ServeContent(name string, r io.ReadSeeker, params ...interface{})

                                                                                    ServeContent serves given content to response.

                                                                                    func (*Context) ServeFile

                                                                                    func (ctx *Context) ServeFile(file string, names ...string)

                                                                                      ServeFile serves given file to response.

                                                                                      func (*Context) ServeFileContent

                                                                                      func (ctx *Context) ServeFileContent(file string, names ...string)

                                                                                        ServeFileContent serves given file as content to response.

                                                                                        func (*Context) SetCookie

                                                                                        func (ctx *Context) SetCookie(name string, value string, others ...interface{})

                                                                                          SetCookie sets given cookie value to response header. FIXME: IE support?

                                                                                          func (*Context) SetParams

                                                                                          func (ctx *Context) SetParams(name, val string)

                                                                                            SetParams sets value of param with given name.

                                                                                            func (*Context) SetSecureCookie

                                                                                            func (ctx *Context) SetSecureCookie(name, value string, others ...interface{})

                                                                                              SetSecureCookie sets given cookie value to response header with default secret string.

                                                                                              func (*Context) SetSuperSecureCookie

                                                                                              func (ctx *Context) SetSuperSecureCookie(secret, name, value string, others ...interface{})

                                                                                                SetSuperSecureCookie sets given cookie value to response header with secret string.

                                                                                                func (*Context) Written

                                                                                                func (c *Context) Written() bool

                                                                                                type ContextInvoker

                                                                                                type ContextInvoker func(ctx *Context)

                                                                                                  ContextInvoker is an inject.FastInvoker wrapper of func(ctx *Context).

                                                                                                  func (ContextInvoker) Invoke

                                                                                                  func (invoke ContextInvoker) Invoke(params []interface{}) ([]reflect.Value, error)

                                                                                                  type Delims

                                                                                                  type Delims struct {
                                                                                                  	// Left delimiter, defaults to {{
                                                                                                  	Left string
                                                                                                  	// Right delimiter, defaults to }}
                                                                                                  	Right string

                                                                                                    Delims represents a set of Left and Right delimiters for HTML template rendering

                                                                                                    type DummyRender

                                                                                                    type DummyRender struct {

                                                                                                      DummyRender is used when user does not choose any real render to use. This way, we can print out friendly message which asks them to register one, instead of ugly and confusing 'nil pointer' panic.

                                                                                                      func (*DummyRender) Error

                                                                                                      func (r *DummyRender) Error(int, ...string)

                                                                                                      func (*DummyRender) HTML

                                                                                                      func (r *DummyRender) HTML(int, string, interface{}, ...HTMLOptions)

                                                                                                      func (*DummyRender) HTMLBytes

                                                                                                      func (r *DummyRender) HTMLBytes(string, interface{}, ...HTMLOptions) ([]byte, error)

                                                                                                      func (*DummyRender) HTMLSet

                                                                                                      func (r *DummyRender) HTMLSet(int, string, string, interface{}, ...HTMLOptions)

                                                                                                      func (*DummyRender) HTMLSetBytes

                                                                                                      func (r *DummyRender) HTMLSetBytes(string, string, interface{}, ...HTMLOptions) ([]byte, error)

                                                                                                      func (*DummyRender) HTMLSetString

                                                                                                      func (r *DummyRender) HTMLSetString(string, string, interface{}, ...HTMLOptions) (string, error)

                                                                                                      func (*DummyRender) HTMLString

                                                                                                      func (r *DummyRender) HTMLString(string, interface{}, ...HTMLOptions) (string, error)

                                                                                                      func (*DummyRender) HasTemplateSet

                                                                                                      func (r *DummyRender) HasTemplateSet(string) bool

                                                                                                      func (*DummyRender) JSON

                                                                                                      func (r *DummyRender) JSON(int, interface{})

                                                                                                      func (*DummyRender) JSONString

                                                                                                      func (r *DummyRender) JSONString(interface{}) (string, error)

                                                                                                      func (*DummyRender) PlainText

                                                                                                      func (r *DummyRender) PlainText(int, []byte)

                                                                                                      func (*DummyRender) RawData

                                                                                                      func (r *DummyRender) RawData(int, []byte)

                                                                                                      func (*DummyRender) SetResponseWriter

                                                                                                      func (r *DummyRender) SetResponseWriter(http.ResponseWriter)

                                                                                                      func (*DummyRender) SetTemplatePath

                                                                                                      func (r *DummyRender) SetTemplatePath(string, string)

                                                                                                      func (*DummyRender) Status

                                                                                                      func (r *DummyRender) Status(int)

                                                                                                      func (*DummyRender) XML

                                                                                                      func (r *DummyRender) XML(int, interface{})

                                                                                                      type HTMLOptions

                                                                                                      type HTMLOptions struct {
                                                                                                      	// Layout template name. Overrides Options.Layout.
                                                                                                      	Layout string

                                                                                                        HTMLOptions is a struct for overriding some rendering Options for specific HTML call

                                                                                                        type Handle

                                                                                                        type Handle func(http.ResponseWriter, *http.Request, Params)

                                                                                                          Handle is a function that can be registered to a route to handle HTTP requests. Like http.HandlerFunc, but has a third parameter for the values of wildcards (variables).

                                                                                                          type Handler

                                                                                                          type Handler interface{}

                                                                                                            Handler can be any callable function. Macaron attempts to inject services into the handler's argument list, and panics if an argument could not be fullfilled via dependency injection.

                                                                                                            func Logger

                                                                                                            func Logger() Handler

                                                                                                              Logger returns a middleware handler that logs the request as it goes in and the response as it goes out.

                                                                                                              func Recovery

                                                                                                              func Recovery() Handler

                                                                                                                Recovery returns a middleware that recovers from any panics and writes a 500 if there was one. While Martini is in development mode, Recovery will also output the panic as HTML.

                                                                                                                func Renderer

                                                                                                                func Renderer(options ...RenderOptions) Handler

                                                                                                                  Renderer is a Middleware that maps a macaron.Render service into the Macaron handler chain. An single variadic macaron.RenderOptions struct can be optionally provided to configure HTML rendering. The default directory for templates is "templates" and the default file extension is ".tmpl" and ".html".

                                                                                                                  If MACARON_ENV is set to "" or "development" then templates will be recompiled on every request. For more performance, set the MACARON_ENV environment variable to "production".

                                                                                                                  func Renderers

                                                                                                                  func Renderers(options RenderOptions, tplSets ...string) Handler

                                                                                                                  func Static

                                                                                                                  func Static(directory string, staticOpt ...StaticOptions) Handler

                                                                                                                    Static returns a middleware handler that serves static files in the given directory.

                                                                                                                    func Statics

                                                                                                                    func Statics(opt StaticOptions, dirs ...string) Handler

                                                                                                                      Statics registers multiple static middleware handlers all at once.

                                                                                                                      type Leaf

                                                                                                                      type Leaf struct {
                                                                                                                      	// contains filtered or unexported fields

                                                                                                                        Leaf represents a leaf route information.

                                                                                                                        func NewLeaf

                                                                                                                        func NewLeaf(parent *Tree, pattern string, handle Handle) *Leaf

                                                                                                                        func (*Leaf) URLPath

                                                                                                                        func (l *Leaf) URLPath(pairs ...string) string

                                                                                                                          URLPath build path part of URL by given pair values.

                                                                                                                          type Locale

                                                                                                                          type Locale interface {
                                                                                                                          	Language() string
                                                                                                                          	Tr(string, ...interface{}) string

                                                                                                                            Locale reprents a localization interface.

                                                                                                                            type LoggerInvoker

                                                                                                                            type LoggerInvoker func(ctx *Context, log *log.Logger)

                                                                                                                              LoggerInvoker is an inject.FastInvoker wrapper of func(ctx *Context, log *log.Logger).

                                                                                                                              func (LoggerInvoker) Invoke

                                                                                                                              func (invoke LoggerInvoker) Invoke(params []interface{}) ([]reflect.Value, error)

                                                                                                                              type Macaron

                                                                                                                              type Macaron struct {
                                                                                                                              	// contains filtered or unexported fields

                                                                                                                                Macaron represents the top level web application. inject.Injector methods can be invoked to map services on a global level.

                                                                                                                                func Classic

                                                                                                                                func Classic() *Macaron

                                                                                                                                  Classic creates a classic Macaron with some basic default middleware: macaron.Logger, macaron.Recovery and macaron.Static.

                                                                                                                                  func New

                                                                                                                                  func New() *Macaron

                                                                                                                                    New creates a bare bones Macaron instance. Use this method if you want to have full control over the middleware that is used.

                                                                                                                                    func NewWithLogger

                                                                                                                                    func NewWithLogger(out io.Writer) *Macaron

                                                                                                                                      NewWithLogger creates a bare bones Macaron instance. Use this method if you want to have full control over the middleware that is used. You can specify logger output writer with this function.

                                                                                                                                      func (*Macaron) Action

                                                                                                                                      func (m *Macaron) Action(handler Handler)

                                                                                                                                        Action sets the handler that will be called after all the middleware has been invoked. This is set to macaron.Router in a macaron.Classic().

                                                                                                                                        func (*Macaron) Before

                                                                                                                                        func (m *Macaron) Before(handler BeforeHandler)

                                                                                                                                        func (*Macaron) Handlers

                                                                                                                                        func (m *Macaron) Handlers(handlers ...Handler)

                                                                                                                                          Handlers sets the entire middleware stack with the given Handlers. This will clear any current middleware handlers, and panics if any of the handlers is not a callable function

                                                                                                                                          func (*Macaron) Run

                                                                                                                                          func (m *Macaron) Run(args ...interface{})

                                                                                                                                            Run the http server. Listening on os.GetEnv("PORT") or 4000 by default.

                                                                                                                                            func (*Macaron) ServeHTTP

                                                                                                                                            func (m *Macaron) ServeHTTP(rw http.ResponseWriter, req *http.Request)

                                                                                                                                              ServeHTTP is the HTTP Entry point for a Macaron instance. Useful if you want to control your own HTTP server. Be aware that none of middleware will run without registering any router.

                                                                                                                                              func (*Macaron) SetDefaultCookieSecret

                                                                                                                                              func (m *Macaron) SetDefaultCookieSecret(secret string)

                                                                                                                                                SetDefaultCookieSecret sets global default secure cookie secret.

                                                                                                                                                func (*Macaron) SetURLPrefix

                                                                                                                                                func (m *Macaron) SetURLPrefix(prefix string)

                                                                                                                                                  SetURLPrefix sets URL prefix of router layer, so that it support suburl.

                                                                                                                                                  func (*Macaron) Use

                                                                                                                                                  func (m *Macaron) Use(handler Handler)

                                                                                                                                                    Use adds a middleware Handler to the stack, and panics if the handler is not a callable func. Middleware Handlers are invoked in the order that they are added.

                                                                                                                                                    type Params

                                                                                                                                                    type Params map[string]string

                                                                                                                                                    type Render

                                                                                                                                                    type Render interface {
                                                                                                                                                    	JSON(int, interface{})
                                                                                                                                                    	JSONString(interface{}) (string, error)
                                                                                                                                                    	RawData(int, []byte)   // Serve content as binary
                                                                                                                                                    	PlainText(int, []byte) // Serve content as plain text
                                                                                                                                                    	HTML(int, string, interface{}, ...HTMLOptions)
                                                                                                                                                    	HTMLSet(int, string, string, interface{}, ...HTMLOptions)
                                                                                                                                                    	HTMLSetString(string, string, interface{}, ...HTMLOptions) (string, error)
                                                                                                                                                    	HTMLString(string, interface{}, ...HTMLOptions) (string, error)
                                                                                                                                                    	HTMLSetBytes(string, string, interface{}, ...HTMLOptions) ([]byte, error)
                                                                                                                                                    	HTMLBytes(string, interface{}, ...HTMLOptions) ([]byte, error)
                                                                                                                                                    	XML(int, interface{})
                                                                                                                                                    	Error(int, ...string)
                                                                                                                                                    	SetTemplatePath(string, string)
                                                                                                                                                    	HasTemplateSet(string) bool

                                                                                                                                                    type RenderOptions

                                                                                                                                                    type RenderOptions struct {
                                                                                                                                                    	// Directory to load templates. Default is "templates".
                                                                                                                                                    	Directory string
                                                                                                                                                    	// Addtional directories to overwite templates.
                                                                                                                                                    	AppendDirectories []string
                                                                                                                                                    	// Layout template name. Will not render a layout if "". Default is to "".
                                                                                                                                                    	Layout string
                                                                                                                                                    	// Extensions to parse template files from. Defaults are [".tmpl", ".html"].
                                                                                                                                                    	Extensions []string
                                                                                                                                                    	// Funcs is a slice of FuncMaps to apply to the template upon compilation. This is useful for helper functions. Default is [].
                                                                                                                                                    	Funcs []template.FuncMap
                                                                                                                                                    	// Delims sets the action delimiters to the specified strings in the Delims struct.
                                                                                                                                                    	Delims Delims
                                                                                                                                                    	// Appends the given charset to the Content-Type header. Default is "UTF-8".
                                                                                                                                                    	Charset string
                                                                                                                                                    	// Outputs human readable JSON.
                                                                                                                                                    	IndentJSON bool
                                                                                                                                                    	// Outputs human readable XML.
                                                                                                                                                    	IndentXML bool
                                                                                                                                                    	// Prefixes the JSON output with the given bytes.
                                                                                                                                                    	PrefixJSON []byte
                                                                                                                                                    	// Prefixes the XML output with the given bytes.
                                                                                                                                                    	PrefixXML []byte
                                                                                                                                                    	// Allows changing of output to XHTML instead of HTML. Default is "text/html"
                                                                                                                                                    	HTMLContentType string
                                                                                                                                                    	// TemplateFileSystem is the interface for supporting any implmentation of template file system.

                                                                                                                                                      RenderOptions represents a struct for specifying configuration options for the Render middleware.

                                                                                                                                                      type Request

                                                                                                                                                      type Request struct {

                                                                                                                                                        Request represents an HTTP request received by a server or to be sent by a client.

                                                                                                                                                        func (*Request) Body

                                                                                                                                                        func (r *Request) Body() *RequestBody

                                                                                                                                                        type RequestBody

                                                                                                                                                        type RequestBody struct {
                                                                                                                                                        	// contains filtered or unexported fields

                                                                                                                                                          RequestBody represents a request body.

                                                                                                                                                          func (*RequestBody) Bytes

                                                                                                                                                          func (rb *RequestBody) Bytes() ([]byte, error)

                                                                                                                                                            Bytes reads and returns content of request body in bytes.

                                                                                                                                                            func (*RequestBody) ReadCloser

                                                                                                                                                            func (rb *RequestBody) ReadCloser() io.ReadCloser

                                                                                                                                                              ReadCloser returns a ReadCloser for request body.

                                                                                                                                                              func (*RequestBody) String

                                                                                                                                                              func (rb *RequestBody) String() (string, error)

                                                                                                                                                                String reads and returns content of request body in string.

                                                                                                                                                                type ResponseWriter

                                                                                                                                                                type ResponseWriter interface {
                                                                                                                                                                	// Status returns the status code of the response or 0 if the response has not been written.
                                                                                                                                                                	Status() int
                                                                                                                                                                	// Written returns whether or not the ResponseWriter has been written.
                                                                                                                                                                	Written() bool
                                                                                                                                                                	// Size returns the size of the response body.
                                                                                                                                                                	Size() int
                                                                                                                                                                	// Before allows for a function to be called before the ResponseWriter has been written to. This is
                                                                                                                                                                	// useful for setting headers or any other operations that must happen before a response has been written.

                                                                                                                                                                  ResponseWriter is a wrapper around http.ResponseWriter that provides extra information about the response. It is recommended that middleware handlers use this construct to wrap a responsewriter if the functionality calls for it.

                                                                                                                                                                  func NewResponseWriter

                                                                                                                                                                  func NewResponseWriter(method string, rw http.ResponseWriter) ResponseWriter

                                                                                                                                                                    NewResponseWriter creates a ResponseWriter that wraps an http.ResponseWriter

                                                                                                                                                                    type ReturnHandler

                                                                                                                                                                    type ReturnHandler func(*Context, []reflect.Value)

                                                                                                                                                                      ReturnHandler is a service that Martini provides that is called when a route handler returns something. The ReturnHandler is responsible for writing to the ResponseWriter based on the values that are passed into this function.

                                                                                                                                                                      type Route

                                                                                                                                                                      type Route struct {
                                                                                                                                                                      	// contains filtered or unexported fields

                                                                                                                                                                        Route represents a wrapper of leaf route and upper level router.

                                                                                                                                                                        func (*Route) Name

                                                                                                                                                                        func (r *Route) Name(name string)

                                                                                                                                                                          Name sets name of route.

                                                                                                                                                                          type Router

                                                                                                                                                                          type Router struct {
                                                                                                                                                                          	// contains filtered or unexported fields

                                                                                                                                                                            Router represents a Macaron router layer.

                                                                                                                                                                            func NewRouter

                                                                                                                                                                            func NewRouter() *Router

                                                                                                                                                                            func (*Router) Any

                                                                                                                                                                            func (r *Router) Any(pattern string, h ...Handler) *Route

                                                                                                                                                                              Any is a shortcut for r.Handle("*", pattern, handlers)

                                                                                                                                                                              func (*Router) Combo

                                                                                                                                                                              func (r *Router) Combo(pattern string, h ...Handler) *ComboRouter

                                                                                                                                                                                Combo returns a combo router.

                                                                                                                                                                                func (*Router) Delete

                                                                                                                                                                                func (r *Router) Delete(pattern string, h ...Handler) *Route

                                                                                                                                                                                  Delete is a shortcut for r.Handle("DELETE", pattern, handlers)

                                                                                                                                                                                  func (*Router) Get

                                                                                                                                                                                  func (r *Router) Get(pattern string, h ...Handler) (leaf *Route)

                                                                                                                                                                                    Get is a shortcut for r.Handle("GET", pattern, handlers)

                                                                                                                                                                                    func (*Router) Group

                                                                                                                                                                                    func (r *Router) Group(pattern string, fn func(), h ...Handler)

                                                                                                                                                                                    func (*Router) Handle

                                                                                                                                                                                    func (r *Router) Handle(method string, pattern string, handlers []Handler) *Route

                                                                                                                                                                                      Handle registers a new request handle with the given pattern, method and handlers.

                                                                                                                                                                                      func (*Router) Head

                                                                                                                                                                                      func (r *Router) Head(pattern string, h ...Handler) *Route

                                                                                                                                                                                        Head is a shortcut for r.Handle("HEAD", pattern, handlers)

                                                                                                                                                                                        func (*Router) InternalServerError

                                                                                                                                                                                        func (r *Router) InternalServerError(handlers ...Handler)

                                                                                                                                                                                          InternalServerError configurates handler which is called when route handler returns error. If it is not set, default handler is used. Be sure to set 500 response code in your handler.

                                                                                                                                                                                          func (*Router) NotFound

                                                                                                                                                                                          func (r *Router) NotFound(handlers ...Handler)

                                                                                                                                                                                            NotFound configurates http.HandlerFunc which is called when no matching route is found. If it is not set, http.NotFound is used. Be sure to set 404 response code in your handler.

                                                                                                                                                                                            func (*Router) Options

                                                                                                                                                                                            func (r *Router) Options(pattern string, h ...Handler) *Route

                                                                                                                                                                                              Options is a shortcut for r.Handle("OPTIONS", pattern, handlers)

                                                                                                                                                                                              func (*Router) Patch

                                                                                                                                                                                              func (r *Router) Patch(pattern string, h ...Handler) *Route

                                                                                                                                                                                                Patch is a shortcut for r.Handle("PATCH", pattern, handlers)

                                                                                                                                                                                                func (*Router) Post

                                                                                                                                                                                                func (r *Router) Post(pattern string, h ...Handler) *Route

                                                                                                                                                                                                  Post is a shortcut for r.Handle("POST", pattern, handlers)

                                                                                                                                                                                                  func (*Router) Put

                                                                                                                                                                                                  func (r *Router) Put(pattern string, h ...Handler) *Route

                                                                                                                                                                                                    Put is a shortcut for r.Handle("PUT", pattern, handlers)

                                                                                                                                                                                                    func (*Router) Route

                                                                                                                                                                                                    func (r *Router) Route(pattern, methods string, h ...Handler) (route *Route)

                                                                                                                                                                                                      Route is a shortcut for same handlers but different HTTP methods.


                                                                                                                                                                                                      m.Route("/", "GET,POST", h)

                                                                                                                                                                                                      func (*Router) ServeHTTP

                                                                                                                                                                                                      func (r *Router) ServeHTTP(rw http.ResponseWriter, req *http.Request)

                                                                                                                                                                                                      func (*Router) SetAutoHead

                                                                                                                                                                                                      func (r *Router) SetAutoHead(v bool)

                                                                                                                                                                                                        SetAutoHead sets the value who determines whether add HEAD method automatically when GET method is added.

                                                                                                                                                                                                        func (*Router) SetHandlerWrapper

                                                                                                                                                                                                        func (r *Router) SetHandlerWrapper(f func(Handler) Handler)

                                                                                                                                                                                                          SetHandlerWrapper sets handlerWrapper for the router.

                                                                                                                                                                                                          func (*Router) URLFor

                                                                                                                                                                                                          func (r *Router) URLFor(name string, pairs ...string) string

                                                                                                                                                                                                            URLFor builds path part of URL by given pair values.

                                                                                                                                                                                                            type StaticOptions

                                                                                                                                                                                                            type StaticOptions struct {
                                                                                                                                                                                                            	// Prefix is the optional prefix used to serve the static directory content
                                                                                                                                                                                                            	Prefix string
                                                                                                                                                                                                            	// SkipLogging will disable [Static] log messages when a static file is served.
                                                                                                                                                                                                            	SkipLogging bool
                                                                                                                                                                                                            	// IndexFile defines which file to serve as index if it exists.
                                                                                                                                                                                                            	IndexFile string
                                                                                                                                                                                                            	// Expires defines which user-defined function to use for producing a HTTP Expires Header
                                                                                                                                                                                                            	Expires func() string
                                                                                                                                                                                                            	// ETag defines if we should add an ETag header
                                                                                                                                                                                                            	ETag bool
                                                                                                                                                                                                            	// FileSystem is the interface for supporting any implmentation of file system.
                                                                                                                                                                                                            	FileSystem http.FileSystem

                                                                                                                                                                                                              StaticOptions is a struct for specifying configuration options for the macaron.Static middleware.

                                                                                                                                                                                                              type TemplateFile

                                                                                                                                                                                                              type TemplateFile interface {
                                                                                                                                                                                                              	Name() string
                                                                                                                                                                                                              	Data() []byte
                                                                                                                                                                                                              	Ext() string

                                                                                                                                                                                                                TemplateFile represents a interface of template file that has name and can be read.

                                                                                                                                                                                                                type TemplateFileSystem

                                                                                                                                                                                                                type TemplateFileSystem interface {
                                                                                                                                                                                                                	ListFiles() []TemplateFile
                                                                                                                                                                                                                	Get(string) (io.Reader, error)

                                                                                                                                                                                                                  TemplateFileSystem represents a interface of template file system that able to list all files.

                                                                                                                                                                                                                  type TemplateSet

                                                                                                                                                                                                                  type TemplateSet struct {
                                                                                                                                                                                                                  	// contains filtered or unexported fields

                                                                                                                                                                                                                    TemplateSet represents a template set of type *template.Template.

                                                                                                                                                                                                                    func NewTemplateSet

                                                                                                                                                                                                                    func NewTemplateSet() *TemplateSet

                                                                                                                                                                                                                      NewTemplateSet initializes a new empty template set.

                                                                                                                                                                                                                      func (*TemplateSet) Get

                                                                                                                                                                                                                      func (ts *TemplateSet) Get(name string) *template.Template

                                                                                                                                                                                                                      func (*TemplateSet) GetDir

                                                                                                                                                                                                                      func (ts *TemplateSet) GetDir(name string) string

                                                                                                                                                                                                                      func (*TemplateSet) Set

                                                                                                                                                                                                                      func (ts *TemplateSet) Set(name string, opt *RenderOptions) *template.Template

                                                                                                                                                                                                                      type TplFile

                                                                                                                                                                                                                      type TplFile struct {
                                                                                                                                                                                                                      	// contains filtered or unexported fields

                                                                                                                                                                                                                        TplFile implements TemplateFile interface.

                                                                                                                                                                                                                        func NewTplFile

                                                                                                                                                                                                                        func NewTplFile(name string, data []byte, ext string) *TplFile

                                                                                                                                                                                                                          NewTplFile cerates new template file with given name and data.

                                                                                                                                                                                                                          func (*TplFile) Data

                                                                                                                                                                                                                          func (f *TplFile) Data() []byte

                                                                                                                                                                                                                          func (*TplFile) Ext

                                                                                                                                                                                                                          func (f *TplFile) Ext() string

                                                                                                                                                                                                                          func (*TplFile) Name

                                                                                                                                                                                                                          func (f *TplFile) Name() string

                                                                                                                                                                                                                          type TplFileSystem

                                                                                                                                                                                                                          type TplFileSystem struct {
                                                                                                                                                                                                                          	// contains filtered or unexported fields

                                                                                                                                                                                                                            TplFileSystem implements TemplateFileSystem interface.

                                                                                                                                                                                                                            func NewTemplateFileSystem

                                                                                                                                                                                                                            func NewTemplateFileSystem(opt RenderOptions, omitData bool) TplFileSystem

                                                                                                                                                                                                                              NewTemplateFileSystem creates new template file system with given options.

                                                                                                                                                                                                                              func (TplFileSystem) Get

                                                                                                                                                                                                                              func (fs TplFileSystem) Get(name string) (io.Reader, error)

                                                                                                                                                                                                                              func (TplFileSystem) ListFiles

                                                                                                                                                                                                                              func (fs TplFileSystem) ListFiles() []TemplateFile

                                                                                                                                                                                                                              type TplRender

                                                                                                                                                                                                                              type TplRender struct {
                                                                                                                                                                                                                              	Opt             *RenderOptions
                                                                                                                                                                                                                              	CompiledCharset string
                                                                                                                                                                                                                              	// contains filtered or unexported fields

                                                                                                                                                                                                                              func (*TplRender) Error

                                                                                                                                                                                                                              func (r *TplRender) Error(status int, message ...string)

                                                                                                                                                                                                                                Error writes the given HTTP status to the current ResponseWriter

                                                                                                                                                                                                                                func (*TplRender) HTML

                                                                                                                                                                                                                                func (r *TplRender) HTML(status int, name string, data interface{}, htmlOpt ...HTMLOptions)

                                                                                                                                                                                                                                func (*TplRender) HTMLBytes

                                                                                                                                                                                                                                func (r *TplRender) HTMLBytes(name string, data interface{}, htmlOpt ...HTMLOptions) ([]byte, error)

                                                                                                                                                                                                                                func (*TplRender) HTMLSet

                                                                                                                                                                                                                                func (r *TplRender) HTMLSet(status int, setName, tplName string, data interface{}, htmlOpt ...HTMLOptions)

                                                                                                                                                                                                                                func (*TplRender) HTMLSetBytes

                                                                                                                                                                                                                                func (r *TplRender) HTMLSetBytes(setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) ([]byte, error)

                                                                                                                                                                                                                                func (*TplRender) HTMLSetString

                                                                                                                                                                                                                                func (r *TplRender) HTMLSetString(setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) (string, error)

                                                                                                                                                                                                                                func (*TplRender) HTMLString

                                                                                                                                                                                                                                func (r *TplRender) HTMLString(name string, data interface{}, htmlOpt ...HTMLOptions) (string, error)

                                                                                                                                                                                                                                func (*TplRender) HasTemplateSet

                                                                                                                                                                                                                                func (r *TplRender) HasTemplateSet(name string) bool

                                                                                                                                                                                                                                func (*TplRender) JSON

                                                                                                                                                                                                                                func (r *TplRender) JSON(status int, v interface{})

                                                                                                                                                                                                                                func (*TplRender) JSONString

                                                                                                                                                                                                                                func (r *TplRender) JSONString(v interface{}) (string, error)

                                                                                                                                                                                                                                func (*TplRender) PlainText

                                                                                                                                                                                                                                func (r *TplRender) PlainText(status int, v []byte)

                                                                                                                                                                                                                                func (*TplRender) RawData

                                                                                                                                                                                                                                func (r *TplRender) RawData(status int, v []byte)

                                                                                                                                                                                                                                func (*TplRender) SetResponseWriter

                                                                                                                                                                                                                                func (r *TplRender) SetResponseWriter(rw http.ResponseWriter)

                                                                                                                                                                                                                                func (*TplRender) SetTemplatePath

                                                                                                                                                                                                                                func (r *TplRender) SetTemplatePath(setName, dir string)

                                                                                                                                                                                                                                func (*TplRender) Status

                                                                                                                                                                                                                                func (r *TplRender) Status(status int)

                                                                                                                                                                                                                                func (*TplRender) XML

                                                                                                                                                                                                                                func (r *TplRender) XML(status int, v interface{})

                                                                                                                                                                                                                                type Tree

                                                                                                                                                                                                                                type Tree struct {
                                                                                                                                                                                                                                	// contains filtered or unexported fields

                                                                                                                                                                                                                                  Tree represents a router tree in Macaron.

                                                                                                                                                                                                                                  func NewSubtree

                                                                                                                                                                                                                                  func NewSubtree(parent *Tree, pattern string) *Tree

                                                                                                                                                                                                                                  func NewTree

                                                                                                                                                                                                                                  func NewTree() *Tree

                                                                                                                                                                                                                                  func (*Tree) Add

                                                                                                                                                                                                                                  func (t *Tree) Add(pattern string, handle Handle) *Leaf

                                                                                                                                                                                                                                  func (*Tree) Match

                                                                                                                                                                                                                                  func (t *Tree) Match(url string) (Handle, Params, bool)