mojito

type Cache interface {
	// Contains returns whether a key is present in the cache
	Contains(key string) (bool, error)
	// Delete removes a cache entry by its key, will do nothing if the
	// key was not present in the cache
	Delete(key string) error
	// ExpireAfter will mark a cache key for expiration after a certain duration
	ExpireAfter(key string, duration time.Duration) error
	// Get will attempt to read a stored cache value into the given
	// out interface pointer or error if not present
	Get(key string, out interface{}) error
	// Get will attempt to read a stored cache value into the given
	// out interface pointer or return default if not found
	GetOrDefault(key string, out interface{}, def interface{}) error
	// Set will attempt to store a value in the cache with a given key
	Set(key string, val interface{}) error
}

type DefaultRouteGroup struct {
	Middlewares []interface{}
	// contains filtered or unexported fields
}

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

type HandlerArgFactory func(req *Request, res *Response, next *HandlerFunc) reflect.Value

type HandlerFunc func(res *Response, req *Request) error

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

type LogFields map[string]interface{}

type Logger interface {
	// Debug will write a debug log
	Debug(msg interface{})
	// Debugf will write a debug log sprintf-style
	Debugf(msg string, values ...interface{})
	// Error will write a error log
	Error(msg interface{})
	// Errorf will write a error log sprintf-style
	Errorf(msg string, values ...interface{})
	// Fatal will write a fatal log
	Fatal(msg interface{})
	// Fatalf will write a fatal log sprintf-style
	Fatalf(msg string, values ...interface{})
	// Field will add a field to a new logger and return it
	Field(name string, val interface{}) Logger
	// Fields will add multiple fields to a new logger and return it
	Fields(fields LogFields) Logger
	// Info will write a info log
	Info(msg interface{})
	// Infof will write a info log sprintf-style
	Infof(msg string, values ...interface{})
	// Trace will write a trace log
	Trace(msg interface{})
	// Tracef will write a trace log sprintf-style
	Tracef(msg string, values ...interface{})
	// Warn will write a warn log
	Warn(msg interface{})
	// Warnf will write a warn log sprintf-style
	Warnf(msg string, values ...interface{})
}

type MiddlewareHandler func(res *Response, req *Request, next interface{}) error

type Renderer interface {
	// Render will load a template file and render the template
	// within using the viewbag as a context
	Render(view string, bag ViewBag) (string, error)
}

type Request struct {
	*http.Request
	Params map[string]string
	// contains filtered or unexported fields
}

type Response struct {
	http.ResponseWriter
	ViewBag ViewBag
}

type RouteGroup interface {
	// DELETE will add a route to this route group for the delete method
	DELETE(path string, handler interface{})
	// GET will add a route to this route group for the get method
	GET(path string, handler interface{})
	// HEAD will add a route to this route group for the head method
	HEAD(path string, handler interface{})
	// POST will add a route to this route group for the post method
	POST(path string, handler interface{})
	// PUT will add a route to this route group for the put method
	PUT(path string, handler interface{})

	// WithMiddleware will add a middleware to the route group
	WithMiddleware(handler interface{})
	// WithRoute will add a new route with the given RouteMethod to the route group
	WithRoute(method RouteMethod, path string, handler interface{})

	// ApplyToRouter will attempt to merge all middlewares with the collected route handlers
	// and then attempt to register the routes on the router with a given prefix.
	// Will return an error if any of the steps throw an error
	ApplyToRouter(router Router, prefix string) error
}

type RouteMethod string

type Router interface {
	// DELETE will add a route to this router for the delete method
	DELETE(path string, handler interface{}) error
	// GET will add a route to this router for the get method
	GET(path string, handler interface{}) error
	// HEAD will add a route to this router for the head method
	HEAD(path string, handler interface{}) error
	// POST will add a route to this router for the post method
	POST(path string, handler interface{}) error
	// PUT will add a route to this router for the put method
	PUT(path string, handler interface{}) error

	// Group is the deprecated version of WithGroup, they do the same thing.
	//
	// Deprecated: For consistency in naming and due to the Routeable interface
	// change, the Group method has been deprecated in favour of WithGroup and
	// its new interface.
	Group(prefix string, callback func(group Routeable)) error

	// WithGroup will create a new route group for the given prefix
	WithGroup(prefix string, callback func(group RouteGroup)) error
	// WithMiddleware will add a middleware to the router
	WithMiddleware(handler interface{}) error
	// WithRoute will add a new route with the given RouteMethod to the router
	WithRoute(method RouteMethod, path string, handler interface{}) error

	// ListenAndServe will start an HTTP webserver on the given address
	ListenAndServe(address string) error

	// Shutdown will stop the HTTP webserver
	Shutdown() error
}

type ViewBag map[string]interface{}