vugu: github.com/vugu/vugu/simplehttp Index | Files

package simplehttp

import "github.com/vugu/vugu/simplehttp"

Package simplehttp provides an http.Handler that makes it easy to serve Vugu applications. Useful for development and production.

The idea is that the common behaviors needed to serve a Vugu site are readily available in one place. If you require more functionality than simplehttp provides, nearly everything it does is available in the github.com/vugu/vugu package and you can construct what you need from its parts. That said, simplehttp should make it easy to start:

// dev flag enables most common development features
// including rebuild your .wasm upon page reload
dev := true
h := simplehttp.New(dir, dev)

After creation, some flags are available for tuning, e.g.:

h.EnableGenerate = true // upon page reload run "go generate ."
h.DisableBuildCache = true // do not try to cache build results during development, just rebuild every time
h.ParserGoPkgOpts.SkipRegisterComponentTypes = true // do not generate component registration init() stuff

Since it's just a regular http.Handler, starting a webserver is as simple as:

log.Fatal(http.ListenAndServe("127.0.0.1:5678", h))

Index

Package Files

simple-handler.go

Variables

var DefaultIsPageFunc = func(r *http.Request) bool {

    return path.Ext(path.Clean("/"+r.URL.Path)) == ""
}

DefaultIsPageFunc will return true for any request to a path with no file extension.

var DefaultPageTemplateSource = "" /* 1420 byte string literal not displayed */

DefaultPageTemplateSource a useful default HTML template for serving pages.

var DefaultStaticData = make(map[string]interface{}, 4)

DefaultStaticData is a map of static things added to the return value of DefaultTemplateDataFunc. Provides a quick and dirty way to do things like add CSS files to every page.

var DefaultTemplateDataFunc = func(r *http.Request) interface{} {
    ret := map[string]interface{}{
        "Request": r,
    }
    for k, v := range DefaultStaticData {
        ret[k] = v
    }
    return ret
}

DefaultTemplateDataFunc is the default behavior for making template data. It returns a map with "Request" set to r and all elements of DefaultStaticData added to it.

func FilteredFileServer Uses

func FilteredFileServer(pattern *regexp.Regexp, fs http.FileSystem) http.Handler

FilteredFileServer is similar to the standard librarie's http.FileServer but the handler it returns will refuse to serve any files which don't match the specified regexp pattern after running through path.Clean(). The idea is to make it easy to serve only specific kinds of static files from a directory. If pattern does not match a 404 will be returned. Be sure to include a trailing "$" if you are checking for file extensions, so it only matches the end of the path, e.g. "[.](css|js)$"

type PageHandler Uses

type PageHandler struct {
    Template         *template.Template
    TemplateDataFunc func(r *http.Request) interface{}
}

PageHandler executes a Go template and responsds with the page.

func (*PageHandler) ServeHTTP Uses

func (h *PageHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP implements http.Handler

type SimpleHandler Uses

type SimpleHandler struct {
    Dir string // project directory

    EnableBuildAndServe          bool                  // enables the build-and-serve sequence for your wasm binary - useful for dev, should be off in production
    EnableGenerate               bool                  // if true calls `go generate` (requires EnableBuildAndServe)
    ParserGoPkgOpts              *vugu.ParserGoPkgOpts // if set enables running ParserGoPkg with these options (requires EnableBuildAndServe)
    DisableBuildCache            bool                  // if true then rebuild every time instead of trying to cache (requires EnableBuildAndServe)
    DisableTimestampPreservation bool                  // if true don't try to keep timestamps the same for files that are byte for byte identical (requires EnableBuildAndServe)
    MainWasmPath                 string                // path to serve main wasm file from, in dev mod defaults to "/main.wasm" (requires EnableBuildAndServe)
    WasmExecJsPath               string                // path to serve wasm_exec.js from after finding in the local Go installation, in dev mode defaults to "/wasm_exec.js"

    IsPage      func(r *http.Request) bool // func that returns true if PageHandler should serve the request
    PageHandler http.Handler               // returns the HTML page

    StaticHandler http.Handler // returns static assets from Dir with appropriate filtering or appropriate error
    // contains filtered or unexported fields
}

SimpleHandler provides common web serving functionality useful for building Vugu sites.

func New Uses

func New(dir string, dev bool) *SimpleHandler

New returns an SimpleHandler ready to serve using the specified directory. The dev flag indicates if development functionality is enabled. Settings on SimpleHandler may be tuned more specifically after creation, this function just returns sensible defaults for development or production according to if dev is true or false.

func (*SimpleHandler) ServeHTTP Uses

func (h *SimpleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP implements http.Handler.

Package simplehttp imports 17 packages (graph). Updated 2019-07-19. Refresh now. Tools for package owners.