revel: github.com/revel/revel Index | Files | Directories

package revel

import "github.com/revel/revel"

Index

Package Files

binder.go compress.go controller.go errors.go field.go filter.go filterconfig.go flash.go http.go i18n.go intercept.go invoker.go libs.go module.go namespace.go panic.go params.go results.go revel.go router.go server.go session.go template.go template_adapter_go.go template_engine.go template_functions.go util.go validation.go validators.go version.go watcher.go

Constants

const (
    DefaultDateFormat     = "2006-01-02"
    DefaultDateTimeFormat = "2006-01-02 15:04"
)

Revel's default date and time constants

const (
    // Called when templates are going to be refreshed (receivers are registered template engines added to the template.engine conf option)
    TEMPLATE_REFRESH_REQUESTED = iota
    // Called when templates are refreshed (receivers are registered template engines added to the template.engine conf option)
    TEMPLATE_REFRESH_COMPLETED

    // Event type before all module loads, events thrown to handlers added to AddInitEventHandler
    REVEL_BEFORE_MODULES_LOADED
    // Event type after all module loads, events thrown to handlers added to AddInitEventHandler
    REVEL_AFTER_MODULES_LOADED

    // Called before routes are refreshed
    ROUTE_REFRESH_REQUESTED
    // Called after routes have been refreshed
    ROUTE_REFRESH_COMPLETED
)
const (
    SessionIDKey = "_ID"
    TimestampKey = "_TS"
)

Session constants

const (
    None               = 0
    IPAny              = 1
    IPv4               = 32 // IPv4 (32 chars)
    IPv6               = 39 // IPv6(39 chars)
    IPv4MappedIPv6     = 45 // IP4-mapped IPv6 (45 chars) , Ex) ::FFFF:129.144.52.38
    IPv4CIDR           = IPv4 + 3
    IPv6CIDR           = IPv6 + 3
    IPv4MappedIPv6CIDR = IPv4MappedIPv6 + 3
)
const (
    NORMAL = 0
    STRICT = 4
)

NORMAL BenchmarkRegex-8 2000000000 0.24 ns/op STRICT BenchmarkLoop-8 2000000000 0.01 ns/op

const (
    ONLY_FILENAME       = 0
    ALLOW_RELATIVE_PATH = 1
)
const (
    // Version current Revel version
    Version = "0.17.1"

    // BuildDate latest commit/release date
    BuildDate = "2017-07-14"

    // MinimumGoVersion minimum required Go version for Revel
    MinimumGoVersion = ">= go1.6"
)
const (
    // CurrentLocaleViewArg the key for the current locale view arg value
    CurrentLocaleViewArg = "currentLocale"
)
const (
    // DefaultFileContentType Revel's default response content type
    DefaultFileContentType = "application/octet-stream"
)
const GO_TEMPLATE = "go"
const (
    // RevelImportPath Revel framework import path
    RevelImportPath = "github.com/revel/revel"
)

Variables

var (
    // These are the lookups to find a Binder for any type of data.
    // The most specific binder found will be used (Type before Kind)
    TypeBinders = make(map[reflect.Type]Binder)
    KindBinders = make(map[reflect.Kind]Binder)

    // Applications can add custom time formats to this array, and they will be
    // automatically attempted when binding a time.Time.
    TimeFormats = []string{}

    DateFormat     string
    DateTimeFormat string

    IntBinder = Binder{
        Bind: ValueBinder(func(val string, typ reflect.Type) reflect.Value {
            if len(val) == 0 {
                return reflect.Zero(typ)
            }
            intValue, err := strconv.ParseInt(val, 10, 64)
            if err != nil {
                WARN.Println(err)
                return reflect.Zero(typ)
            }
            pValue := reflect.New(typ)
            pValue.Elem().SetInt(intValue)
            return pValue.Elem()
        }),
        Unbind: func(output map[string]string, key string, val interface{}) {
            output[key] = fmt.Sprintf("%d", val)
        },
    }

    UintBinder = Binder{
        Bind: ValueBinder(func(val string, typ reflect.Type) reflect.Value {
            if len(val) == 0 {
                return reflect.Zero(typ)
            }
            uintValue, err := strconv.ParseUint(val, 10, 64)
            if err != nil {
                WARN.Println(err)
                return reflect.Zero(typ)
            }
            pValue := reflect.New(typ)
            pValue.Elem().SetUint(uintValue)
            return pValue.Elem()
        }),
        Unbind: func(output map[string]string, key string, val interface{}) {
            output[key] = fmt.Sprintf("%d", val)
        },
    }

    FloatBinder = Binder{
        Bind: ValueBinder(func(val string, typ reflect.Type) reflect.Value {
            if len(val) == 0 {
                return reflect.Zero(typ)
            }
            floatValue, err := strconv.ParseFloat(val, 64)
            if err != nil {
                WARN.Println(err)
                return reflect.Zero(typ)
            }
            pValue := reflect.New(typ)
            pValue.Elem().SetFloat(floatValue)
            return pValue.Elem()
        }),
        Unbind: func(output map[string]string, key string, val interface{}) {
            output[key] = fmt.Sprintf("%f", val)
        },
    }

    StringBinder = Binder{
        Bind: ValueBinder(func(val string, typ reflect.Type) reflect.Value {
            return reflect.ValueOf(val)
        }),
        Unbind: func(output map[string]string, name string, val interface{}) {
            output[name] = val.(string)
        },
    }

    // Booleans support a various value formats,
    // refer `revel.Atob` method.
    BoolBinder = Binder{
        Bind: ValueBinder(func(val string, typ reflect.Type) reflect.Value {
            return reflect.ValueOf(Atob(val))
        }),
        Unbind: func(output map[string]string, name string, val interface{}) {
            output[name] = fmt.Sprintf("%t", val)
        },
    }

    PointerBinder = Binder{
        Bind: func(params *Params, name string, typ reflect.Type) reflect.Value {
            v := Bind(params, name, typ.Elem())
            if v.CanAddr() {
                return v.Addr()
            }

            return v
        },
        Unbind: func(output map[string]string, name string, val interface{}) {
            Unbind(output, name, reflect.ValueOf(val).Elem().Interface())
        },
    }

    TimeBinder = Binder{
        Bind: ValueBinder(func(val string, typ reflect.Type) reflect.Value {
            for _, f := range TimeFormats {
                if r, err := time.Parse(f, val); err == nil {
                    return reflect.ValueOf(r)
                }
            }
            return reflect.Zero(typ)
        }),
        Unbind: func(output map[string]string, name string, val interface{}) {
            var (
                t       = val.(time.Time)
                format  = DateTimeFormat
                h, m, s = t.Clock()
            )
            if h == 0 && m == 0 && s == 0 {
                format = DateFormat
            }
            output[name] = t.Format(format)
        },
    }

    MapBinder = Binder{
        Bind:   bindMap,
        Unbind: unbindMap,
    }
)

Binders type and kind definition

var (
    NilFilter = func(_ *Controller, _ []Filter) {}
    NilChain  = []Filter{NilFilter}
)

NilFilter and NilChain are helpful in writing filter tests.

var (
    AppName    string // e.g. "sample"
    AppRoot    string // e.g. "/app1"
    BasePath   string // e.g. "$GOPATH/src/corp/sample"
    AppPath    string // e.g. "$GOPATH/src/corp/sample/app"
    ViewsPath  string // e.g. "$GOPATH/src/corp/sample/app/views"
    ImportPath string // e.g. "corp/sample"
    SourcePath string // e.g. "$GOPATH/src"

    Config  *config.Context
    RunMode string // Application-defined (by default, "dev" or "prod")
    DevMode bool   // if true, RunMode is a development mode.

    // Revel installation details
    RevelPath string // e.g. "$GOPATH/src/github.com/revel/revel"

    // Where to look for templates
    // Ordered by priority. (Earlier paths take precedence over later paths.)
    CodePaths     []string
    TemplatePaths []string

    // ConfPaths where to look for configurations
    // Config load order
    // 1. framework (revel/conf/*)
    // 2. application (conf/*)
    // 3. user supplied configs (...) - User configs can override/add any from above
    ConfPaths []string

    // Server config.
    //
    // Alert: This is how the app is configured, which may be different from
    // the current process reality.  For example, if the app is configured for
    // port 9000, HTTPPort will always be 9000, even though in dev mode it is
    // run on a random port and proxied.
    HTTPPort    int    // e.g. 9000
    HTTPAddr    string // e.g. "", "127.0.0.1"
    HTTPSsl     bool   // e.g. true if using ssl
    HTTPSslCert string // e.g. "/path/to/cert.pem"
    HTTPSslKey  string // e.g. "/path/to/key.pem"

    // All cookies dropped by the framework begin with this prefix.
    CookiePrefix string
    // Cookie domain
    CookieDomain string
    // Cookie flags
    CookieSecure bool

    // Delimiters to use when rendering templates
    TemplateDelims string

    // Loggers
    TRACE = log.New(ioutil.Discard, "TRACE ", log.Ldate|log.Ltime|log.Lshortfile)
    INFO  = log.New(ioutil.Discard, "INFO ", log.Ldate|log.Ltime|log.Lshortfile)
    WARN  = log.New(ioutil.Discard, "WARN ", log.Ldate|log.Ltime|log.Lshortfile)
    ERROR = log.New(&errorLog, "ERROR ", log.Ldate|log.Ltime|log.Lshortfile)

    Initialized bool
)

App details

var (
    MainRouter         *Router
    MainTemplateLoader *TemplateLoader
    MainWatcher        *Watcher
    Server             *http.Server
)

Revel's variables server, router, etc

var DefaultValidationKeys map[string]map[int]string

DefaultValidationKeys register default validation keys for all calls to Controller.Validation.Func(). Map from (package).func => (line => name of first arg to Validation func) E.g. "myapp/controllers.helper" or "myapp/controllers.(*Application).Action" This is set on initialization in the generated main.go file.

var ErrorCSSClass = "hasError"

ErrorCSSClass httml CSS error class name

var Filters = []Filter{
    PanicFilter,
    RouterFilter,
    FilterConfiguringFilter,
    ParamsFilter,
    SessionFilter,
    FlashFilter,
    ValidationFilter,
    I18nFilter,
    InterceptorFilter,
    CompressFilter,
    ActionInvoker,
}

Filters is the default set of global filters. It may be set by the application on initialization.

var MessageFunc = Message

MessageFunc allows you to override the translation interface.

Set this to your own function that translates to the current locale. This allows you to set up your own loading and logging of translated texts.

See Message(...) in i18n.go for example of function.

var (
    Modules []*Module // The list of modules in use

)
var (
    // The functions available for use in the templates.
    TemplateFuncs = map[string]interface{}{
        "url": ReverseURL,
        "set": func(viewArgs map[string]interface{}, key string, value interface{}) template.JS {
            viewArgs[key] = value
            return template.JS("")
        },
        "append": func(viewArgs map[string]interface{}, key string, value interface{}) template.JS {
            if viewArgs[key] == nil {
                viewArgs[key] = []interface{}{value}
            } else {
                viewArgs[key] = append(viewArgs[key].([]interface{}), value)
            }
            return template.JS("")
        },
        "field": NewField,
        "firstof": func(args ...interface{}) interface{} {
            for _, val := range args {
                switch val.(type) {
                case nil:
                    continue
                case string:
                    if val == "" {
                        continue
                    }
                    return val
                default:
                    return val
                }
            }
            return nil
        },
        "option": func(f *Field, val interface{}, label string) template.HTML {
            selected := ""
            if f.Flash() == val || (f.Flash() == "" && f.Value() == val) {
                selected = " selected"
            }

            return template.HTML(fmt.Sprintf(`<option value="%s"%s>%s</option>`,
                html.EscapeString(fmt.Sprintf("%v", val)), selected, html.EscapeString(label)))
        },
        "radio": func(f *Field, val string) template.HTML {
            checked := ""
            if f.Flash() == val {
                checked = " checked"
            }
            return template.HTML(fmt.Sprintf(`<input type="radio" name="%s" value="%s"%s>`,
                html.EscapeString(f.Name), html.EscapeString(val), checked))
        },
        "checkbox": func(f *Field, val string) template.HTML {
            checked := ""
            if f.Flash() == val {
                checked = " checked"
            }
            return template.HTML(fmt.Sprintf(`<input type="checkbox" name="%s" value="%s"%s>`,
                html.EscapeString(f.Name), html.EscapeString(val), checked))
        },

        "pad": func(str string, width int) template.HTML {
            if len(str) >= width {
                return template.HTML(html.EscapeString(str))
            }
            return template.HTML(html.EscapeString(str) + strings.Repeat("&nbsp;", width-len(str)))
        },

        "errorClass": func(name string, viewArgs map[string]interface{}) template.HTML {
            errorMap, ok := viewArgs["errors"].(map[string]*ValidationError)
            if !ok || errorMap == nil {
                WARN.Println("Called 'errorClass' without 'errors' in the view args.")
                return template.HTML("")
            }
            valError, ok := errorMap[name]
            if !ok || valError == nil {
                return template.HTML("")
            }
            return template.HTML(ErrorCSSClass)
        },

        "msg": func(viewArgs map[string]interface{}, message string, args ...interface{}) template.HTML {
            str, ok := viewArgs[CurrentLocaleViewArg].(string)
            if !ok {
                return ""
            }
            return template.HTML(MessageFunc(str, message, args...))
        },

        "nl2br": func(text string) template.HTML {
            return template.HTML(strings.Replace(template.HTMLEscapeString(text), "\n", "<br>", -1))
        },

        "raw": func(text string) template.HTML {
            return template.HTML(text)
        },

        "pluralize": func(items interface{}, pluralOverrides ...string) string {
            singular, plural := "", "s"
            if len(pluralOverrides) >= 1 {
                singular = pluralOverrides[0]
                if len(pluralOverrides) == 2 {
                    plural = pluralOverrides[1]
                }
            }

            switch v := reflect.ValueOf(items); v.Kind() {
            case reflect.Int:
                if items.(int) != 1 {
                    return plural
                }
            case reflect.Slice:
                if v.Len() != 1 {
                    return plural
                }
            default:
                ERROR.Println("pluralize: unexpected type: ", v)
            }
            return singular
        },

        "date": func(date time.Time) string {
            return date.Format(DateFormat)
        },
        "datetime": func(date time.Time) string {
            return date.Format(DateTimeFormat)
        },
        "slug": Slug,
        "even": func(a int) bool { return (a % 2) == 0 },
        "i18ntemplate": func(args ...interface{}) (template.HTML, error) {
            templateName, lang := "", ""
            var viewArgs interface{}
            switch len(args) {
            case 0:
                ERROR.Printf("No arguements passed to template call")
            case 1:

                templateName = args[0].(string)
            case 2:

                templateName = args[0].(string)
                viewArgs = args[1]

                if viewargsmap, ok := viewArgs.(map[string]interface{}); ok {
                    lang, _ = viewargsmap[CurrentLocaleViewArg].(string)
                }
            default:

                templateName = args[0].(string)
                viewArgs = args[1]
                lang, _ = args[2].(string)
                if len(args) > 3 {
                    ERROR.Printf("Received more parameters then needed for %s", templateName)
                }
            }

            var buf bytes.Buffer

            tmpl, err := MainTemplateLoader.TemplateLang(templateName, lang)
            if err == nil {
                err = tmpl.Render(&buf, viewArgs)
            } else {
                ERROR.Printf("Failed to render i18ntemplate %s %v", templateName, err)
            }
            return template.HTML(buf.String()), err
        },
    }
)
var WatchFilter = func(c *Controller, fc []Filter) {
    if MainWatcher != nil {
        err := MainWatcher.Notify()
        if err != nil {
            c.Result = c.RenderError(err)
            return
        }
    }
    fc[0](c, fc[1:])
}

func ActionInvoker Uses

func ActionInvoker(c *Controller, _ []Filter)

func AddInitEventHandler Uses

func AddInitEventHandler(handler EventHandler)

Add event handler to listen for all system events

func Atob Uses

func Atob(v string) bool

Atob converts string into boolean. It is in-case sensitive When converting to boolean, the following values are considered FALSE: - The "" (empty) string - The "false" string - The "f" string - The "off" string, - The string "0" & "0.0"

func Bind Uses

func Bind(params *Params, name string, typ reflect.Type) reflect.Value

Bind takes the name and type of the desired parameter and constructs it from one or more values from Params. Returns the zero value of the type upon any sort of failure.

func BindFile Uses

func BindFile(fileHeader *multipart.FileHeader, typ reflect.Type) reflect.Value

func BindValue Uses

func BindValue(val string, typ reflect.Type) reflect.Value

func CheckInit Uses

func CheckInit()

CheckInit method checks `revel.Initialized` if not initialized it panics

func ClientIP Uses

func ClientIP(r *http.Request) string

ClientIP method returns client IP address from HTTP request.

Note: Set property "app.behind.proxy" to true only if Revel is running behind proxy like nginx, haproxy, apache, etc. Otherwise you may get inaccurate Client IP address. Revel parses the IP address in the order of X-Forwarded-For, X-Real-IP.

By default revel will get http.Request's RemoteAddr

func CompressFilter Uses

func CompressFilter(c *Controller, fc []Filter)

CompressFilter does compresssion of response body in gzip/deflate if `results.compressed=true` in the app.conf

func ContainsString Uses

func ContainsString(list []string, target string) bool

func ContentTypeByFilename Uses

func ContentTypeByFilename(filename string) string

ContentTypeByFilename returns a MIME content type based on the filename's extension. If no appropriate one is found, returns "application/octet-stream" by default. Additionally, specifies the charset as UTF-8 for text/* types.

func DirExists Uses

func DirExists(filename string) bool

DirExists returns true if the given path exists and is a directory.

func EngineHandles Uses

func EngineHandles(engine TemplateEngine, templateView *TemplateView) bool

func Equal Uses

func Equal(a, b interface{}) bool

Equal is a helper for comparing value equality, following these rules:

- Values with equivalent types are compared with reflect.DeepEqual
- int, uint, and float values are compared without regard to the type width.
  for example, Equal(int32(5), int64(5)) == true
- strings and byte slices are converted to strings before comparison.
- else, return false.

func ExecuteTemplate Uses

func ExecuteTemplate(tmpl ExecutableTemplate, data interface{}) string

ExecuteTemplate execute a template and returns the result as a string.

func FilterConfiguringFilter Uses

func FilterConfiguringFilter(c *Controller, fc []Filter)

FilterConfiguringFilter is a filter stage that customizes the remaining filter chain for the action being invoked.

func FilterEq Uses

func FilterEq(a, b Filter) bool

FilterEq returns true if the two filters reference the same filter.

func FindMethod Uses

func FindMethod(recvType reflect.Type, funcVal reflect.Value) *reflect.Method

FindMethod returns the reflect.Method, given a Receiver type and Func value.

func FirstNonEmpty Uses

func FirstNonEmpty(strs ...string) string

func FlashFilter Uses

func FlashFilter(c *Controller, fc []Filter)

FlashFilter is a Revel Filter that retrieves and sets the flash cookie. Within Revel, it is available as a Flash attribute on Controller instances. The name of the Flash cookie is set as CookiePrefix + "_FLASH".

func HTTPMethodOverride Uses

func HTTPMethodOverride(c *Controller, fc []Filter)

HTTPMethodOverride overrides allowed http methods via form or browser param

func Handle Uses

func Handle(w http.ResponseWriter, r *http.Request)

This method handles all requests. It dispatches to handleInternal after handling / adapting websocket connections.

func I18nFilter Uses

func I18nFilter(c *Controller, fc []Filter)

func Init Uses

func Init(mode, importPath, srcPath string)

Init initializes Revel -- it provides paths for getting around the app.

Params:

mode - the run mode, which determines which app.conf settings are used.
importPath - the Go import path of the application.
srcPath - the path to the source directory, containing Revel and the app.
  If not specified (""), then a functioning Go installation is required.

func InitServer Uses

func InitServer() http.HandlerFunc

InitServer intializes the server and returns the handler It can be used as an alternative entry-point if one needs the http handler to be exposed. E.g. to run on multiple addresses and ports or to set custom TLS options.

func InterceptFunc Uses

func InterceptFunc(intc InterceptorFunc, when When, target interface{})

InterceptFunc installs a general interceptor. This can be applied to any Controller. It must have the signature of:

func example(c *revel.Controller) revel.Result

func InterceptMethod Uses

func InterceptMethod(intc InterceptorMethod, when When)

InterceptMethod installs an interceptor method that applies to its own Controller.

func (c AppController) example() revel.Result
func (c *AppController) example() revel.Result

func InterceptorFilter Uses

func InterceptorFilter(c *Controller, fc []Filter)

func LoadMimeConfig Uses

func LoadMimeConfig()

LoadMimeConfig load mime-types.conf on init.

func Message Uses

func Message(locale, message string, args ...interface{}) string

Message performs a message look-up for the given locale and message using the given arguments.

When either an unknown locale or message is detected, a specially formatted string is returned.

func MessageLanguages Uses

func MessageLanguages() []string

MessageLanguages returns all currently loaded message languages.

func MustReadLines Uses

func MustReadLines(filename string) []string

MustReadLines reads the lines of the given file. Panics in the case of error.

func OnAppStart Uses

func OnAppStart(f func(), order ...int)

OnAppStart registers a function to be run at app startup.

The order you register the functions will be the order they are run. You can think of it as a FIFO queue. This process will happen after the config file is read and before the server is listening for connections.

Ideally, your application should have only one call to init() in the file init.go. The reason being that the call order of multiple init() functions in the same package is undefined. Inside of init() call revel.OnAppStart() for each function you wish to register.

Example:

// from: yourapp/app/controllers/somefile.go
func InitDB() {
    // do DB connection stuff here
}

func FillCache() {
    // fill a cache from DB
    // this depends on InitDB having been run
}

// from: yourapp/app/init.go
func init() {
    // set up filters...

    // register startup functions
    revel.OnAppStart(InitDB)
    revel.OnAppStart(FillCache)
}

This can be useful when you need to establish connections to databases or third-party services, setup app components, compile assets, or any thing you need to do between starting Revel and accepting connections.

func PanicFilter Uses

func PanicFilter(c *Controller, fc []Filter)

PanicFilter wraps the action invocation in a protective defer blanket that converts panics into 500 error pages.

func ParamsFilter Uses

func ParamsFilter(c *Controller, fc []Filter)

func ParseKeyValueCookie Uses

func ParseKeyValueCookie(val string, cb func(key, val string))

ParseKeyValueCookie takes the raw (escaped) cookie value and parses out key values.

func ParseParams Uses

func ParseParams(params *Params, req *Request)

ParseParams parses the `http.Request` params into `revel.Controller.Params`

func ParseTemplateError Uses

func ParseTemplateError(err error) (templateName string, line int, description string)

Parse the line, and description from an error message like: html/template:Application/Register.html:36: no such template "footer.html"

func ReadLines Uses

func ReadLines(filename string) ([]string, error)

ReadLines reads the lines of the given file. Panics in the case of error.

func RegisterController Uses

func RegisterController(c interface{}, methods []*MethodType)

RegisterController registers a Controller and its Methods with Revel.

func RegisterTemplateLoader Uses

func RegisterTemplateLoader(key string, loader func(loader *TemplateLoader) (TemplateEngine, error)) (err error)

Allow for templates to be registered during init but not initialized until application has been started

func ResolveContentType Uses

func ResolveContentType(req *http.Request) string

ResolveContentType gets the content type. e.g. From "multipart/form-data; boundary=--" to "multipart/form-data" If none is specified, returns "text/html" by default.

func ResolveFormat Uses

func ResolveFormat(req *http.Request) string

ResolveFormat maps the request's Accept MIME type declaration to a Request.Format attribute, specifically "html", "xml", "json", or "txt", returning a default of "html" when Accept header cannot be mapped to a value above.

func ResolveImportPath Uses

func ResolveImportPath(importPath string) (string, error)

ResolveImportPath returns the filesystem path for the given import path. Returns an error if the import path could not be found.

func ReverseURL Uses

func ReverseURL(args ...interface{}) (template.URL, error)

ReverseURL returns a url capable of invoking a given controller method: "Application.ShowApp 123" => "/app/123"

func RouterFilter Uses

func RouterFilter(c *Controller, fc []Filter)

func Run Uses

func Run(port int)

Run the server. This is called from the generated main file. If port is non-zero, use that. Else, read the port from app.conf.

func SessionFilter Uses

func SessionFilter(c *Controller, fc []Filter)

SessionFilter is a Revel Filter that retrieves and sets the session cookie. Within Revel, it is available as a Session attribute on Controller instances. The name of the Session cookie is set as CookiePrefix + "_SESSION".

func SetSecretKey Uses

func SetSecretKey(newKey []byte) error

func Sign Uses

func Sign(message string) string

Sign a given string with the app-configured secret key. If no secret key is set, returns the empty string. Return the signature in base64 (URLEncoding).

func Slug Uses

func Slug(text string) string

func ToBool Uses

func ToBool(val interface{}) bool

ToBool method converts/assert value into true or false. Default is true. When converting to boolean, the following values are considered FALSE: - The integer value is 0 (zero) - The float value 0.0 (zero) - The complex value 0.0 (zero) - For string value, please refer `revel.Atob` method - An array, map, slice with zero elements - Boolean value returned as-is - "nil" value

func Unbind Uses

func Unbind(output map[string]string, name string, val interface{})

func ValidationFilter Uses

func ValidationFilter(c *Controller, fc []Filter)

ValidationFilter revel Filter function to be hooked into the filter chain.

func ValueBinder Uses

func ValueBinder(f func(value string, typ reflect.Type) reflect.Value) func(*Params, string, reflect.Type) reflect.Value

ValueBinder is adapter for easily making one-key-value binders.

func Verify Uses

func Verify(message, sig string) bool

Verify returns true if the given signature is correct for the given message. e.g. it matches what we generate with Sign()

func Walk Uses

func Walk(root string, walkFn filepath.WalkFunc) error

Walk method extends filepath.Walk to also follow symlinks. Always returns the path of the file or directory.

type AcceptLanguage Uses

type AcceptLanguage struct {
    Language string
    Quality  float32
}

AcceptLanguage is a single language from the Accept-Language HTTP header.

type AcceptLanguages Uses

type AcceptLanguages []AcceptLanguage

AcceptLanguages is collection of sortable AcceptLanguage instances.

func ResolveAcceptLanguage Uses

func ResolveAcceptLanguage(req *http.Request) AcceptLanguages

ResolveAcceptLanguage returns a sorted list of Accept-Language header values.

The results are sorted using the quality defined in the header for each language range with the most qualified language range as the first element in the slice.

See the HTTP header fields specification (http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4) for more details.

func (AcceptLanguages) Len Uses

func (al AcceptLanguages) Len() int

func (AcceptLanguages) Less Uses

func (al AcceptLanguages) Less(i, j int) bool

func (AcceptLanguages) String Uses

func (al AcceptLanguages) String() string

func (AcceptLanguages) Swap Uses

func (al AcceptLanguages) Swap(i, j int)

type ActionDefinition Uses

type ActionDefinition struct {
    Host, Method, URL, Action string
    Star                      bool
    Args                      map[string]string
}

func (*ActionDefinition) String Uses

func (a *ActionDefinition) String() string

type ActionPathData Uses

type ActionPathData struct {
    Key                 string            // The unique key
    ControllerNamespace string            // The controller namespace
    ControllerName      string            // The controller name
    MethodName          string            // The method name
    Action              string            // The action
    ModuleSource        *Module           // The module
    Route               *Route            // The route
    FixedParamsByName   map[string]string // The fixed parameters
    TypeOfController    *ControllerType   // The controller type
}

type BinaryResult Uses

type BinaryResult struct {
    Reader   io.Reader
    Name     string
    Length   int64
    Delivery ContentDisposition
    ModTime  time.Time
}

func (*BinaryResult) Apply Uses

func (r *BinaryResult) Apply(req *Request, resp *Response)

type Binder Uses

type Binder struct {
    // Bind takes the name and type of the desired parameter and constructs it
    // from one or more values from Params.
    //
    // Example
    //
    // Request:
    //   url?id=123&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=rob
    //
    // Action:
    //   Example.Action(id int, ol []int, ul []string, user User)
    //
    // Calls:
    //   Bind(params, "id", int): 123
    //   Bind(params, "ol", []int): {1, 2}
    //   Bind(params, "ul", []string): {"str", "array"}
    //   Bind(params, "user", User): User{Name:"rob"}
    //
    // Note that only exported struct fields may be bound.
    Bind func(params *Params, name string, typ reflect.Type) reflect.Value

    // Unbind serializes a given value to one or more URL parameters of the given
    // name.
    Unbind func(output map[string]string, name string, val interface{})
}

A Binder translates between string parameters and Go data structures.

type CompressResponseWriter Uses

type CompressResponseWriter struct {
    http.ResponseWriter
    // contains filtered or unexported fields
}

func (*CompressResponseWriter) Close Uses

func (c *CompressResponseWriter) Close() error

func (CompressResponseWriter) CloseNotify Uses

func (c CompressResponseWriter) CloseNotify() <-chan bool

func (*CompressResponseWriter) DetectCompressionType Uses

func (c *CompressResponseWriter) DetectCompressionType(req *Request, resp *Response)

DetectCompressionType method detects the comperssion type from header "Accept-Encoding"

func (*CompressResponseWriter) Write Uses

func (c *CompressResponseWriter) Write(b []byte) (int, error)

func (*CompressResponseWriter) WriteHeader Uses

func (c *CompressResponseWriter) WriteHeader(status int)

type ContentDisposition Uses

type ContentDisposition string
var (
    Attachment ContentDisposition = "attachment"
    Inline     ContentDisposition = "inline"
)

type Controller Uses

type Controller struct {
    Name          string          // The controller name, e.g. "Application"
    Type          *ControllerType // A description of the controller type.
    MethodName    string          // The method name, e.g. "Index"
    MethodType    *MethodType     // A description of the invoked action type.
    AppController interface{}     // The controller that was instantiated.
    Action        string          // The fully qualified action name, e.g. "App.Index"
    ClientIP      string          // holds IP address of request came from

    Request  *Request
    Response *Response
    Result   Result

    Flash      Flash                  // User cookie, cleared after 1 request.
    Session    Session                // Session, stored in cookie, signed.
    Params     *Params                // Parameters from URL and form (including multipart).
    Args       map[string]interface{} // Per-request scratch space.
    ViewArgs   map[string]interface{} // Variables passed to the template.
    Validation *Validation            // Data validation helpers
}

Controller Revel's controller structure that gets embedded in user defined controllers

func NewController Uses

func NewController(req *Request, resp *Response) *Controller

NewController returns new controller instance for Request and Response

func (*Controller) FlashParams Uses

func (c *Controller) FlashParams()

FlashParams serializes the contents of Controller.Params to the Flash cookie.

func (*Controller) Forbidden Uses

func (c *Controller) Forbidden(msg string, objs ...interface{}) Result

Forbidden returns an HTTP 403 Forbidden response whose body is the formatted string of msg and objs.

func (*Controller) Message Uses

func (c *Controller) Message(message string, args ...interface{}) (value string)

Message performs a lookup for the given message name using the given arguments using the current language defined for this controller.

The current language is set by the i18n plugin.

func (*Controller) NotFound Uses

func (c *Controller) NotFound(msg string, objs ...interface{}) Result

NotFound returns an HTTP 404 Not Found response whose body is the formatted string of msg and objs.

func (*Controller) Redirect Uses

func (c *Controller) Redirect(val interface{}, args ...interface{}) Result

Redirect to an action or to a URL.

c.Redirect(Controller.Action)
c.Redirect("/controller/action")
c.Redirect("/controller/%d/action", id)

func (*Controller) Render Uses

func (c *Controller) Render(extraViewArgs ...interface{}) Result

Render a template corresponding to the calling Controller method. Arguments will be added to c.ViewArgs prior to rendering the template. They are keyed on their local identifier.

For example:

func (c Users) ShowUser(id int) revel.Result {
	 user := loadUser(id)
	 return c.Render(user)
}

This action will render views/Users/ShowUser.html, passing in an extra key-value "user": (User).

This is the slower magical version which uses the runtime to determine 1) Set c.ViewArgs to the arguments passed into this function 2) How to call the RenderTemplate by building the following line c.RenderTemplate(c.Name + "/" + c.MethodType.Name + "." + c.Request.Format)

If you want your code to run faster it is recommended you add the template values directly to the c.ViewArgs and call c.RenderTemplate directly

func (*Controller) RenderBinary Uses

func (c *Controller) RenderBinary(memfile io.Reader, filename string, delivery ContentDisposition, modtime time.Time) Result

RenderBinary is like RenderFile() except that it instead of a file on disk, it renders data from memory (which could be a file that has not been written, the output from some function, or bytes streamed from somewhere else, as long it implements io.Reader). When called directly on something generated or streamed, modtime should mostly likely be time.Now().

func (*Controller) RenderError Uses

func (c *Controller) RenderError(err error) Result

func (*Controller) RenderFile Uses

func (c *Controller) RenderFile(file *os.File, delivery ContentDisposition) Result

RenderFile returns a file, either displayed inline or downloaded as an attachment. The name and size are taken from the file info.

func (*Controller) RenderHTML Uses

func (c *Controller) RenderHTML(html string) Result

RenderHTML renders html in response

func (*Controller) RenderJSON Uses

func (c *Controller) RenderJSON(o interface{}) Result

RenderJSON uses encoding/json.Marshal to return JSON to the client.

func (*Controller) RenderJSONP Uses

func (c *Controller) RenderJSONP(callback string, o interface{}) Result

RenderJSONP renders JSONP result using encoding/json.Marshal

func (*Controller) RenderTemplate Uses

func (c *Controller) RenderTemplate(templatePath string) Result

RenderTemplate method does less magical way to render a template. Renders the given template, using the current ViewArgs.

func (*Controller) RenderText Uses

func (c *Controller) RenderText(text string, objs ...interface{}) Result

RenderText renders plaintext in response, printf style.

func (*Controller) RenderXML Uses

func (c *Controller) RenderXML(o interface{}) Result

RenderXML uses encoding/xml.Marshal to return XML to the client.

func (*Controller) SetAction Uses

func (c *Controller) SetAction(controllerName, methodName string) error

SetAction sets the action that is being invoked in the current request. It sets the following properties: Name, Action, Type, MethodType

func (*Controller) SetCookie Uses

func (c *Controller) SetCookie(cookie *http.Cookie)

func (*Controller) SetTypeAction Uses

func (c *Controller) SetTypeAction(controllerName, methodName string, typeOfController *ControllerType) error

SetAction sets the assigns the Controller type, sets the action and initializes the controller

func (*Controller) Todo Uses

func (c *Controller) Todo() Result

Todo returns an HTTP 501 Not Implemented "todo" indicating that the action isn't done yet.

type ControllerType Uses

type ControllerType struct {
    Namespace         string  // The namespace of the controller
    ModuleSource      *Module // The module for the controller
    Type              reflect.Type
    Methods           []*MethodType
    ControllerIndexes [][]int // FieldByIndex to all embedded *Controllers
}

func AddControllerType Uses

func AddControllerType(moduleSource *Module, controllerType reflect.Type, methods []*MethodType) (newControllerType *ControllerType)

Adds the controller to the controllers map using its namespace, also adds it to the module list of controllers. If the controller is in the main application it is added without its namespace as well.

func ControllerTypeByName Uses

func ControllerTypeByName(controllerName string, moduleSource *Module) (c *ControllerType)

func (*ControllerType) Method Uses

func (ct *ControllerType) Method(name string) *MethodType

Method searches for a given exported method (case insensitive)

func (*ControllerType) Name Uses

func (ct *ControllerType) Name() string

The controller name with the namespace

func (*ControllerType) ShortName Uses

func (ct *ControllerType) ShortName() string

The controller name without the namespace

type DiscerningListener Uses

type DiscerningListener interface {
    Listener
    WatchDir(info os.FileInfo) bool
    WatchFile(basename string) bool
}

DiscerningListener allows the receiver to selectively watch files.

type Domain Uses

type Domain struct {
    Regexp *regexp.Regexp
}

Requires a Domain string to be exactly

func ValidDomain Uses

func ValidDomain() Domain

func (Domain) DefaultMessage Uses

func (d Domain) DefaultMessage() string

func (Domain) IsSatisfied Uses

func (d Domain) IsSatisfied(obj interface{}) bool

type Email Uses

type Email struct {
    Match
}

func ValidEmail Uses

func ValidEmail() Email

func (Email) DefaultMessage Uses

func (e Email) DefaultMessage() string

type Error Uses

type Error struct {
    SourceType               string   // The type of source that failed to build.
    Title, Path, Description string   // Description of the error, as presented to the user.
    Line, Column             int      // Where the error was encountered.
    SourceLines              []string // The entire source file, split into lines.
    Stack                    string   // The raw stack trace string from debug.Stack().
    MetaError                string   // Error that occurred producing the error page.
    Link                     string   // A configurable link to wrap the error source in
}

Error description, used as an argument to the error template.

func NewErrorFromPanic Uses

func NewErrorFromPanic(err interface{}) *Error

NewErrorFromPanic method finds the deepest stack from in user code and provide a code listing of that, on the line that eventually triggered the panic. Returns nil if no relevant stack frame can be found.

func (*Error) ContextSource Uses

func (e *Error) ContextSource() []SourceLine

ContextSource method returns a snippet of the source around where the error occurred.

func (*Error) Error Uses

func (e *Error) Error() string

Error method constructs a plaintext version of the error, taking account that fields are optionally set. Returns e.g. Compilation Error (in views/header.html:51): expected right delim in end; got "}"

func (e *Error) SetLink(errorLink string)

SetLink method prepares a link and assign to Error.Link attribute

type ErrorResult Uses

type ErrorResult struct {
    ViewArgs map[string]interface{}
    Error    error
}

ErrorResult structure used to handles all kinds of error codes (500, 404, ..). It renders the relevant error page (errors/CODE.format, e.g. errors/500.json). If RunMode is "dev", this results in a friendly error page.

func (ErrorResult) Apply Uses

func (r ErrorResult) Apply(req *Request, resp *Response)

type EventHandler Uses

type EventHandler func(typeOf int, value interface{}) (responseOf int)

type ExecutableTemplate Uses

type ExecutableTemplate interface {
    Execute(io.Writer, interface{}) error
}

ExecutableTemplate adds some more methods to the default Template.

type Field Uses

type Field struct {
    Name  string
    Error *ValidationError
    // contains filtered or unexported fields
}

Field represents a data field that may be collected in a web form.

func NewField Uses

func NewField(name string, renderArgs map[string]interface{}) *Field

func (*Field) ErrorClass Uses

func (f *Field) ErrorClass() string

ErrorClass returns ErrorCSSClass if this field has a validation error, else empty string.

func (*Field) Flash Uses

func (f *Field) Flash() string

Flash returns the flashed value of this Field.

func (*Field) FlashArray Uses

func (f *Field) FlashArray() []string

FlashArray returns the flashed value of this Field as a list split on comma.

func (*Field) ID Uses

func (f *Field) ID() string

ID returns an identifier suitable for use as an HTML id.

func (*Field) Value Uses

func (f *Field) Value() interface{}

Value returns the current value of this Field.

type FilePath Uses

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

Requires an string to be sanitary file path

func ValidFilePath Uses

func ValidFilePath(m int) FilePath

func (FilePath) DefaultMessage Uses

func (f FilePath) DefaultMessage() string

func (FilePath) IsSatisfied Uses

func (f FilePath) IsSatisfied(obj interface{}) bool

type Filter Uses

type Filter func(c *Controller, filterChain []Filter)

Filter type definition for Revel's filter

type FilterConfigurator Uses

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

FilterConfigurator allows the developer configure the filter chain on a per-controller or per-action basis. The filter configuration is applied by the FilterConfiguringFilter, which is itself a filter stage. For example,

Assuming:

Filters = []Filter{
  RouterFilter,
  FilterConfiguringFilter,
  SessionFilter,
  ActionInvoker,
}

Add:

FilterAction(App.Action).
  Add(OtherFilter)

=> RouterFilter, FilterConfiguringFilter, SessionFilter, OtherFilter, ActionInvoker

Remove:

FilterAction(App.Action).
  Remove(SessionFilter)

=> RouterFilter, FilterConfiguringFilter, OtherFilter, ActionInvoker

Insert:

FilterAction(App.Action).
  Insert(OtherFilter, revel.BEFORE, SessionFilter)

=> RouterFilter, FilterConfiguringFilter, OtherFilter, SessionFilter, ActionInvoker

Filter modifications may be combined between Controller and Action. For example:

 FilterController(App{}).
   Add(Filter1)
 FilterAction(App.Action).
   Add(Filter2)

.. would result in App.Action being filtered by both Filter1 and Filter2.

Note: the last filter stage is not subject to the configurator. In particular, Add() adds a filter to the second-to-last place.

func FilterAction Uses

func FilterAction(methodRef interface{}) FilterConfigurator

FilterAction returns a configurator for the filters applied to the given controller method. For example:

FilterAction(MyController.MyAction)

func FilterController Uses

func FilterController(controllerInstance interface{}) FilterConfigurator

FilterController returns a configurator for the filters applied to all actions on the given controller instance. For example:

FilterController(MyController{})

func (FilterConfigurator) Add Uses

func (conf FilterConfigurator) Add(f Filter) FilterConfigurator

Add the given filter in the second-to-last position in the filter chain. (Second-to-last so that it is before ActionInvoker)

func (FilterConfigurator) Insert Uses

func (conf FilterConfigurator) Insert(insert Filter, where When, target Filter) FilterConfigurator

Insert a filter into the filter chain before or after another. This may be called with the BEFORE or AFTER constants, for example:

revel.FilterAction(App.Index).
  Insert(MyFilter, revel.BEFORE, revel.ActionInvoker).
  Insert(MyFilter2, revel.AFTER, revel.PanicFilter)

func (FilterConfigurator) Remove Uses

func (conf FilterConfigurator) Remove(target Filter) FilterConfigurator

Remove a filter from the filter chain.

type Flash Uses

type Flash struct {
    // `Data` is the input which is read in `restoreFlash`, `Out` is the output which is set in a FLASH cookie at the end of the `FlashFilter()`
    Data, Out map[string]string
}

Flash represents a cookie that is overwritten on each request. It allows data to be stored across one page at a time. This is commonly used to implement success or error messages. E.g. the Post/Redirect/Get pattern: http://en.wikipedia.org/wiki/Post/Redirect/Get

func (Flash) Error Uses

func (f Flash) Error(msg string, args ...interface{})

Error serializes the given msg and args to an "error" key within the Flash cookie.

func (Flash) Success Uses

func (f Flash) Success(msg string, args ...interface{})

Success serializes the given msg and args to a "success" key within the Flash cookie.

type GoEngine Uses

type GoEngine struct {
    CaseInsensitiveMode bool
    // contains filtered or unexported fields
}

func (*GoEngine) ConvertPath Uses

func (i *GoEngine) ConvertPath(path string) string

func (*GoEngine) Event Uses

func (engine *GoEngine) Event(action int, i interface{})

func (*GoEngine) Handles Uses

func (i *GoEngine) Handles(templateView *TemplateView) bool

func (*GoEngine) Lookup Uses

func (engine *GoEngine) Lookup(templateName string) Template

func (*GoEngine) Name Uses

func (engine *GoEngine) Name() string

func (*GoEngine) ParseAndAdd Uses

func (engine *GoEngine) ParseAndAdd(baseTemplate *TemplateView) error

type GoTemplate Uses

type GoTemplate struct {
    *template.Template

    *TemplateView
    // contains filtered or unexported fields
}

Adapter for Go Templates.

func (GoTemplate) Render Uses

func (gotmpl GoTemplate) Render(wr io.Writer, arg interface{}) error

return a 'revel.Template' from Go's template.

type IPAddr Uses

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

Requires a string(IP Address) to be within IP Pattern type inclusive.

func ValidIPAddr Uses

func ValidIPAddr(cktypes ...int) IPAddr

Requires an IP Address string to be exactly a given validation type (IPv4, IPv6, IPv4MappedIPv6, IPv4CIDR, IPv6CIDR, IPv4MappedIPv6CIDR OR IPAny)

func (IPAddr) DefaultMessage Uses

func (i IPAddr) DefaultMessage() string

func (IPAddr) IsSatisfied Uses

func (i IPAddr) IsSatisfied(obj interface{}) bool

type InterceptTarget Uses

type InterceptTarget int
const (
    AllControllers InterceptTarget = iota
)

type Interception Uses

type Interception struct {
    When When
    // contains filtered or unexported fields
}

func (Interception) Invoke Uses

func (i Interception) Invoke(val reflect.Value) reflect.Value

Invoke performs the given interception. val is a pointer to the App Controller.

type InterceptorFunc Uses

type InterceptorFunc func(*Controller) Result

An InterceptorFunc is functionality invoked by the framework BEFORE or AFTER an action.

An interceptor may optionally return a Result (instead of nil). Depending on when the interceptor was invoked, the response is different: 1. BEFORE: No further interceptors are invoked, and neither is the action. 2. AFTER: Further interceptors are still run. In all cases, any returned Result will take the place of any existing Result.

In the BEFORE case, that returned Result is guaranteed to be final, while in the AFTER case it is possible that a further interceptor could emit its own Result.

Interceptors are called in the order that they are added.

***

Two types of interceptors are provided: Funcs and Methods

Func Interceptors may apply to any / all Controllers.

func example(*revel.Controller) revel.Result

Method Interceptors are provided so that properties can be set on application controllers.

func (c AppController) example() revel.Result
func (c *AppController) example() revel.Result

type InterceptorMethod Uses

type InterceptorMethod interface{}

type Length Uses

type Length struct {
    N int
}

Length requires an array or string to be exactly a given length.

func ValidLength Uses

func ValidLength(n int) Length

func (Length) DefaultMessage Uses

func (s Length) DefaultMessage() string

func (Length) IsSatisfied Uses

func (s Length) IsSatisfied(obj interface{}) bool

type Listener Uses

type Listener interface {
    // Refresh is invoked by the watcher on relevant filesystem events.
    // If the listener returns an error, it is served to the user on the current request.
    Refresh() *Error
}

Listener is an interface for receivers of filesystem events.

type MacAddr Uses

type MacAddr struct{}

Requires a MAC Address string to be exactly

func ValidMacAddr Uses

func ValidMacAddr() MacAddr

func (MacAddr) DefaultMessage Uses

func (m MacAddr) DefaultMessage() string

func (MacAddr) IsSatisfied Uses

func (m MacAddr) IsSatisfied(obj interface{}) bool

type Match Uses

type Match struct {
    Regexp *regexp.Regexp
}

Match requires a string to match a given regex.

func ValidMatch Uses

func ValidMatch(regex *regexp.Regexp) Match

func (Match) DefaultMessage Uses

func (m Match) DefaultMessage() string

func (Match) IsSatisfied Uses

func (m Match) IsSatisfied(obj interface{}) bool

type Max Uses

type Max struct {
    Max int
}

func ValidMax Uses

func ValidMax(max int) Max

func (Max) DefaultMessage Uses

func (m Max) DefaultMessage() string

func (Max) IsSatisfied Uses

func (m Max) IsSatisfied(obj interface{}) bool

type MaxSize Uses

type MaxSize struct {
    Max int
}

MaxSize requires an array or string to be at most a given length.

func ValidMaxSize Uses

func ValidMaxSize(max int) MaxSize

func (MaxSize) DefaultMessage Uses

func (m MaxSize) DefaultMessage() string

func (MaxSize) IsSatisfied Uses

func (m MaxSize) IsSatisfied(obj interface{}) bool

type MethodArg Uses

type MethodArg struct {
    Name string
    Type reflect.Type
}

type MethodType Uses

type MethodType struct {
    Name           string
    Args           []*MethodArg
    RenderArgNames map[int][]string
    // contains filtered or unexported fields
}

type Min Uses

type Min struct {
    Min int
}

func ValidMin Uses

func ValidMin(min int) Min

func (Min) DefaultMessage Uses

func (m Min) DefaultMessage() string

func (Min) IsSatisfied Uses

func (m Min) IsSatisfied(obj interface{}) bool

type MinSize Uses

type MinSize struct {
    Min int
}

MinSize requires an array or string to be at least a given length.

func ValidMinSize Uses

func ValidMinSize(min int) MinSize

func (MinSize) DefaultMessage Uses

func (m MinSize) DefaultMessage() string

func (MinSize) IsSatisfied Uses

func (m MinSize) IsSatisfied(obj interface{}) bool

type Module Uses

type Module struct {
    Name, ImportPath, Path string
    ControllerTypeList     []*ControllerType
}

Module specific functions

func ModuleByName Uses

func ModuleByName(name string) (m *Module, found bool)

ModuleByName returns the module of the given name, if loaded, case insensitive.

func ModuleFromPath Uses

func ModuleFromPath(path string, addGopathToPath bool) (module *Module)

Based on the full path given return the relevant module Only to be used on initialization

func (*Module) AddController Uses

func (m *Module) AddController(ct *ControllerType)

Adds the controller type to this module

func (*Module) ControllerByName Uses

func (m *Module) ControllerByName(name, action string) (ctype *ControllerType)

Returns the named controller and action that is in this module

func (*Module) Namespace Uses

func (m *Module) Namespace() (namespace string)

Returns the namespace for the module in the format `module_name|`

type Params Uses

type Params struct {
    url.Values // A unified view of all the individual param maps below.

    // Set by the router
    Fixed url.Values // Fixed parameters from the route, e.g. App.Action("fixed param")
    Route url.Values // Parameters extracted from the route,  e.g. /customers/{id}

    // Set by the ParamsFilter
    Query url.Values // Parameters from the query string, e.g. /index?limit=10
    Form  url.Values // Parameters from the request body.

    Files map[string][]*multipart.FileHeader // Files uploaded in a multipart form

    JSON []byte // JSON data from request body
    // contains filtered or unexported fields
}

Params provides a unified view of the request params. Includes: - URL query string - Form values - File uploads

Warning: param maps other than Values may be nil if there were none.

func (*Params) Bind Uses

func (p *Params) Bind(dest interface{}, name string)

Bind looks for the named parameter, converts it to the requested type, and writes it into "dest", which must be settable. If the value can not be parsed, "dest" is set to the zero value.

func (*Params) BindJSON Uses

func (p *Params) BindJSON(dest interface{}) error

Bind binds the JSON data to the dest.

type PlaintextErrorResult Uses

type PlaintextErrorResult struct {
    Error error
}

func (PlaintextErrorResult) Apply Uses

func (r PlaintextErrorResult) Apply(req *Request, resp *Response)

Apply method is used when the template loader or error template is not available.

type PureText Uses

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

Requires a string to be without invisible characters

func ValidPureText Uses

func ValidPureText(m int) PureText

func (PureText) DefaultMessage Uses

func (p PureText) DefaultMessage() string

func (PureText) IsSatisfied Uses

func (p PureText) IsSatisfied(obj interface{}) bool

type Range Uses

type Range struct {
    Min
    Max
}

Range requires an integer to be within Min, Max inclusive.

func ValidRange Uses

func ValidRange(min, max int) Range

func (Range) DefaultMessage Uses

func (r Range) DefaultMessage() string

func (Range) IsSatisfied Uses

func (r Range) IsSatisfied(obj interface{}) bool

type RedirectToActionResult Uses

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

func (*RedirectToActionResult) Apply Uses

func (r *RedirectToActionResult) Apply(req *Request, resp *Response)

type RedirectToURLResult Uses

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

func (*RedirectToURLResult) Apply Uses

func (r *RedirectToURLResult) Apply(req *Request, resp *Response)

type RenderHTMLResult Uses

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

func (RenderHTMLResult) Apply Uses

func (r RenderHTMLResult) Apply(req *Request, resp *Response)

type RenderJSONResult Uses

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

func (RenderJSONResult) Apply Uses

func (r RenderJSONResult) Apply(req *Request, resp *Response)

type RenderTemplateResult Uses

type RenderTemplateResult struct {
    Template Template
    ViewArgs map[string]interface{}
}

RenderTemplateResult action methods returns this result to request a template be rendered.

func (*RenderTemplateResult) Apply Uses

func (r *RenderTemplateResult) Apply(req *Request, resp *Response)

type RenderTextResult Uses

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

func (RenderTextResult) Apply Uses

func (r RenderTextResult) Apply(req *Request, resp *Response)

type RenderXMLResult Uses

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

func (RenderXMLResult) Apply Uses

func (r RenderXMLResult) Apply(req *Request, resp *Response)

type Request Uses

type Request struct {
    *http.Request
    ContentType     string
    Format          string // "html", "xml", "json", or "txt"
    AcceptLanguages AcceptLanguages
    Locale          string
    Websocket       *websocket.Conn
}

Request Revel's HTTP request object structure

func NewRequest Uses

func NewRequest(r *http.Request) *Request

NewRequest returns a Revel's HTTP request instance with given HTTP instance

type Required Uses

type Required struct{}

func ValidRequired Uses

func ValidRequired() Required

func (Required) DefaultMessage Uses

func (r Required) DefaultMessage() string

func (Required) IsSatisfied Uses

func (r Required) IsSatisfied(obj interface{}) bool

type Response Uses

type Response struct {
    Status      int
    ContentType string

    Out http.ResponseWriter
}

Response Revel's HTTP response object structure

func NewResponse Uses

func NewResponse(w http.ResponseWriter) *Response

NewResponse returns a Revel's HTTP response instance with given instance

func (*Response) WriteHeader Uses

func (resp *Response) WriteHeader(defaultStatusCode int, defaultContentType string)

WriteHeader writes the header (for now, just the status code). The status may be set directly by the application (c.Response.Status = 501). if it isn't, then fall back to the provided status code.

type Result Uses

type Result interface {
    Apply(req *Request, resp *Response)
}

type Route Uses

type Route struct {
    ModuleSource        *Module         // Module name of route
    Method              string          // e.g. GET
    Path                string          // e.g. /app/:id
    Action              string          // e.g. "Application.ShowApp", "404"
    ControllerNamespace string          // e.g. "testmodule.",
    ControllerName      string          // e.g. "Application", ""
    MethodName          string          // e.g. "ShowApp", ""
    FixedParams         []string        // e.g. "arg1","arg2","arg3" (CSV formatting)
    TreePath            string          // e.g. "/GET/app/:id"
    TypeOfController    *ControllerType // The controller type (if route is not wild carded)
    // contains filtered or unexported fields
}

func NewRoute Uses

func NewRoute(moduleSource *Module, method, path, action, fixedArgs, routesPath string, line int) (r *Route)

NewRoute prepares the route to be used in matching.

func (*Route) ActionPath Uses

func (route *Route) ActionPath() string

type RouteMatch Uses

type RouteMatch struct {
    Action           string // e.g. 404
    ControllerName   string // e.g. Application
    MethodName       string // e.g. ShowApp
    FixedParams      []string
    Params           map[string][]string // e.g. {id: 123}
    TypeOfController *ControllerType     // The controller type
}

type Router Uses

type Router struct {
    Routes []*Route
    Tree   *pathtree.Node
    Module string // The module the route is associated with
    // contains filtered or unexported fields
}

func NewRouter Uses

func NewRouter(routesPath string) *Router

func (*Router) Refresh Uses

func (router *Router) Refresh() (err *Error)

Refresh re-reads the routes file and re-calculates the routing table. Returns an error if a specified action could not be found.

func (*Router) Reverse Uses

func (router *Router) Reverse(action string, argValues map[string]string) (ad *ActionDefinition)

func (*Router) Route Uses

func (router *Router) Route(req *http.Request) (routeMatch *RouteMatch)

type Session Uses

type Session map[string]string

Session a signed cookie (and thus limited to 4kb in size). Restriction: Keys may not have a colon in them.

func GetSessionFromCookie Uses

func GetSessionFromCookie(cookie *http.Cookie) Session

GetSessionFromCookie returns a Session struct pulled from the signed session cookie.

func (Session) Cookie Uses

func (s Session) Cookie() *http.Cookie

Cookie returns an http.Cookie containing the signed session.

func (Session) ID Uses

func (s Session) ID() string

ID retrieves from the cookie or creates a time-based UUID identifying this session.

func (Session) SetDefaultExpiration Uses

func (s Session) SetDefaultExpiration()

SetDefaultExpiration sets session to expire after default duration

func (Session) SetNoExpiration Uses

func (s Session) SetNoExpiration()

SetNoExpiration sets session to expire when browser session ends

type SourceLine Uses

type SourceLine struct {
    Source  string
    Line    int
    IsError bool
}

SourceLine structure to hold the per-source-line details.

type StartupHook Uses

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

type StartupHooks Uses

type StartupHooks []StartupHook

func (StartupHooks) Len Uses

func (slice StartupHooks) Len() int

func (StartupHooks) Less Uses

func (slice StartupHooks) Less(i, j int) bool

func (StartupHooks) Swap Uses

func (slice StartupHooks) Swap(i, j int)

type Template Uses

type Template interface {
    // The name of the template.
    Name() string // Name of template
    // The content of the template as a string (Used in error handling).
    Content() []string // Content
    // Called by the server to render the template out the io.Writer, context contains the view args to be passed to the template.
    Render(wr io.Writer, context interface{}) error
    // The full path to the file on the disk.
    Location() string // Disk location
}

type TemplateEngine Uses

type TemplateEngine interface {
    // prase template string and add template to the set.
    ParseAndAdd(basePath *TemplateView) error

    // returns Template corresponding to the given templateName, or nil
    Lookup(templateName string) Template

    // Fired by the template loader when events occur
    Event(event int, arg interface{})

    // returns true if this engine should be used to parse the file specified in baseTemplate
    Handles(templateView *TemplateView) bool

    // returns the name of the engine
    Name() string
}

type TemplateLoader Uses

type TemplateLoader struct {

    // Map from template name to the path from whence it was loaded.
    TemplatePaths map[string]string
    // A map of looked up template results
    TemplateMap map[string]Template
    // contains filtered or unexported fields
}

TemplateLoader object handles loading and parsing of templates. Everything below the application's views directory is treated as a template.

func NewTemplateLoader Uses

func NewTemplateLoader(paths []string) *TemplateLoader

func (*TemplateLoader) CreateTemplateEngine Uses

func (loader *TemplateLoader) CreateTemplateEngine(templateEngineName string) (TemplateEngine, error)

Sets the template name from Config Sets the template API methods for parsing and storing templates before rendering

func (*TemplateLoader) InitializeEngines Uses

func (loader *TemplateLoader) InitializeEngines(templateEngineNameList string) (err *Error)

Passing in a comma delimited list of engine names to be used with this loader to parse the template files

func (*TemplateLoader) Refresh Uses

func (loader *TemplateLoader) Refresh() (err *Error)

Refresh method scans the views directory and parses all templates as Go Templates. If a template fails to parse, the error is set on the loader. (It's awkward to refresh a single Go Template) Refresh method scans the views directory and parses all templates as Go Templates. If a template fails to parse, the error is set on the loader. (It's awkward to refresh a single Go Template)

func (*TemplateLoader) Template Uses

func (loader *TemplateLoader) Template(name string) (tmpl Template, err error)

DEPRECATED Use TemplateLang, will be removed in future release

func (*TemplateLoader) TemplateLang Uses

func (loader *TemplateLoader) TemplateLang(name, lang string) (tmpl Template, err error)

Template returns the Template with the given name. The name is the template's path relative to a template loader root.

An Error is returned if there was any problem with any of the templates. (In this case, if a template is returned, it may still be usable.)

func (*TemplateLoader) WatchDir Uses

func (loader *TemplateLoader) WatchDir(info os.FileInfo) bool

WatchDir returns true of directory doesn't start with . (dot) otherwise false

func (*TemplateLoader) WatchFile Uses

func (loader *TemplateLoader) WatchFile(basename string) bool

WatchFile returns true of file doesn't start with . (dot) otherwise false

type TemplateView Uses

type TemplateView struct {
    TemplateName string // The name of the view
    FilePath     string // The file path (view relative)
    BasePath     string // The file system base path
    FileBytes    []byte // The file loaded
    EngineType   string // The name of the engine used to render the view
}

The template view information

func NewBaseTemplate Uses

func NewBaseTemplate(templateName, filePath, basePath string, fileBytes []byte) *TemplateView

func (*TemplateView) Content Uses

func (i *TemplateView) Content() (content []string)

func (*TemplateView) Location Uses

func (i *TemplateView) Location() string

type URL Uses

type URL struct {
    Domain
}

func ValidURL Uses

func ValidURL() URL

func (URL) DefaultMessage Uses

func (u URL) DefaultMessage() string

func (URL) IsSatisfied Uses

func (u URL) IsSatisfied(obj interface{}) bool

type Validation Uses

type Validation struct {
    Errors []*ValidationError
    // contains filtered or unexported fields
}

Validation context manages data validation and error messages.

func (*Validation) Check Uses

func (v *Validation) Check(obj interface{}, checks ...Validator) *ValidationResult

Check applies a group of validators to a field, in order, and return the ValidationResult from the first one that fails, or the last one that succeeds.

func (*Validation) Clear Uses

func (v *Validation) Clear()

Clear *all* ValidationErrors

func (*Validation) Domain Uses

func (v *Validation) Domain(str string) *ValidationResult

func (*Validation) Email Uses

func (v *Validation) Email(str string) *ValidationResult

func (*Validation) Error Uses

func (v *Validation) Error(message string, args ...interface{}) *ValidationResult

Error adds an error to the validation context.

func (*Validation) ErrorMap Uses

func (v *Validation) ErrorMap() map[string]*ValidationError

ErrorMap returns the errors mapped by key. If there are multiple validation errors associated with a single key, the first one "wins". (Typically the first validation will be the more basic).

func (*Validation) FilePath Uses

func (v *Validation) FilePath(str string, m int) *ValidationResult

func (*Validation) HasErrors Uses

func (v *Validation) HasErrors() bool

HasErrors returns true if there are any (ie > 0) errors. False otherwise.

func (*Validation) IPAddr Uses

func (v *Validation) IPAddr(str string, cktype ...int) *ValidationResult

func (*Validation) Keep Uses

func (v *Validation) Keep()

Keep tells revel to set a flash cookie on the client to make the validation errors available for the next request. This is helpful when redirecting the client after the validation failed. It is good practice to always redirect upon a HTTP POST request. Thus one should use this method when HTTP POST validation failed and redirect the user back to the form.

func (*Validation) Length Uses

func (v *Validation) Length(obj interface{}, n int) *ValidationResult

func (*Validation) MacAddr Uses

func (v *Validation) MacAddr(str string) *ValidationResult

func (*Validation) Match Uses

func (v *Validation) Match(str string, regex *regexp.Regexp) *ValidationResult

func (*Validation) Max Uses

func (v *Validation) Max(n int, max int) *ValidationResult

func (*Validation) MaxSize Uses

func (v *Validation) MaxSize(obj interface{}, max int) *ValidationResult

func (*Validation) Min Uses

func (v *Validation) Min(n int, min int) *ValidationResult

func (*Validation) MinSize Uses

func (v *Validation) MinSize(obj interface{}, min int) *ValidationResult

func (*Validation) PureText Uses

func (v *Validation) PureText(str string, m int) *ValidationResult

func (*Validation) Range Uses

func (v *Validation) Range(n, min, max int) *ValidationResult

func (*Validation) Required Uses

func (v *Validation) Required(obj interface{}) *ValidationResult

Required tests that the argument is non-nil and non-empty (if string or list)

func (*Validation) URL Uses

func (v *Validation) URL(str string) *ValidationResult

type ValidationError Uses

type ValidationError struct {
    Message, Key string
}

ValidationError simple struct to store the Message & Key of a validation error

func (*ValidationError) String Uses

func (e *ValidationError) String() string

String returns the Message field of the ValidationError struct.

type ValidationResult Uses

type ValidationResult struct {
    Error *ValidationError
    Ok    bool
}

ValidationResult is returned from every validation method. It provides an indication of success, and a pointer to the Error (if any).

func (*ValidationResult) Key Uses

func (r *ValidationResult) Key(key string) *ValidationResult

Key sets the ValidationResult's Error "key" and returns itself for chaining

func (*ValidationResult) Message Uses

func (r *ValidationResult) Message(message string, args ...interface{}) *ValidationResult

Message sets the error message for a ValidationResult. Returns itself to allow chaining. Allows Sprintf() type calling with multiple parameters

type Validator Uses

type Validator interface {
    IsSatisfied(interface{}) bool
    DefaultMessage() string
}

type Watcher Uses

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

Watcher allows listeners to register to be notified of changes under a given directory.

func NewWatcher Uses

func NewWatcher() *Watcher

func (*Watcher) Listen Uses

func (w *Watcher) Listen(listener Listener, roots ...string)

Listen registers for events within the given root directories (recursively).

func (*Watcher) Notify Uses

func (w *Watcher) Notify() *Error

Notify causes the watcher to forward any change events to listeners. It returns the first (if any) error returned.

func (*Watcher) NotifyWhenUpdated Uses

func (w *Watcher) NotifyWhenUpdated(listener Listener, watcher *fsnotify.Watcher)

NotifyWhenUpdated notifies the watcher when a file event is received.

type When Uses

type When int
const (
    BEFORE When = iota
    AFTER
    PANIC
    FINALLY
)

type WriteFlusher Uses

type WriteFlusher interface {
    io.Writer
    io.Closer
    Flush() error
}

WriteFlusher interface for compress writer

Directories

PathSynopsis
cache
testing

Package revel imports 40 packages (graph) and is imported by 443 packages. Updated 2017-07-18. Refresh now. Tools for package owners.