router

type BasicHTTPHandler ¶

type BasicHTTPHandler interface {
	ServeHTTP(http.ResponseWriter, *http.Request) error
}

BasicHTTPHandler defines a request interface which defines a type which will be used to service a http request.

type ErrorHandler ¶

type ErrorHandler struct {
	Handler BasicHTTPHandler
}

ErrorHandler defines a new HTTPHandler which is used to service a request and respond to a giving error that occurs.

func (e ErrorHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

type HTTPCacheHandler ¶

type HTTPCacheHandler interface {
	ServeHTTP(http.ResponseWriter, *http.Request, cache.Cache)
}

HTTPCacheHandler defines a handler which implements a type which allows a handler to have access to a current request and response with the underline cache being used.

type HTTPHandler ¶

type HTTPHandler interface {
	ServeHTTP(http.ResponseWriter, *http.Request)
}

HTTPHandler defines a request interface which defines a type which will be used to service a http request.

func NewErrorHandler(bh BasicHTTPHandler) HTTPHandler

type HandleMux ¶

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

HandleMux defines a structure which handles the variaties in the supported request handlers of the router package and encapsulates the needed behaviour calls.

func NewHandleMux(handler interface{}) HandleMux

func (m HandleMux) Match(path string) (string, HTTPCacheHandler, error)

func (m HandleMux) ServeHTTP(w http.ResponseWriter, r *http.Request, c cache.Cache)

type Handler ¶

type Handler func(PushEvent)

Handler defines a function type for a Resolver subcriber.

type Multiplexer ¶

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

Multiplexer defines a struct which manages giving set of Mux and adequates calls the first to match a giving request about a incoming request.

func NewMultiplexer(mx ...Mux) Multiplexer

func (m Multiplexer) Match(path string) (string, HTTPCacheHandler, error)

type Mux ¶

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

Mux defines a structure which giving a Matcher and a handler which implements either the HTTPCacheHandler/BasicHandler/HTTPHandler and also optionally the PreprocessorHandler, where request being serviced will receive a new path when called and will be used to define, which part an external service will use to service a incoming relative path request. Below is demonstrated a scenario where Mux can be used for to handle request for specific namespace. Scenrio:

Mux has URI Matcher for github/*

When:

Mux receives request for github/gu-io/buba

If Mux has Preprocessor to to transform path to github.com/path:

Then: Path returned is github.com/gu-io/buba

If Mux has No Preprocessor

Then: Path returned is gu-io/buba.

func NewMux(namespace string, handler interface{}) Mux

func (m *Mux) Match(path string) (string, HTTPCacheHandler, error)

type NilServer ¶

type NilServer struct{}

NilServer defines a empty struct implementing the http.Handler interface.

func (NilServer) ServeHTTP(_ http.ResponseWriter, _ *http.Request)

type Params ¶

type Params map[string]string

Params defines a map type of key-value pairs to be sent as query parameters.

type PreprocessHandler ¶

type PreprocessHandler interface {
	Preprocess(string) string
}

PreprocessHandler exposes a type which implements both the http.Handler and a method which pre-processes giving routes for use in a request.

type PushDirectiveEvent ¶

type PushDirectiveEvent struct {
	To string
}

PushDirectiveEvent defines a event which is used to declare the switching of the route to another path provided.

type PushEvent ¶

type PushEvent struct {
	Host   string
	Hash   string
	Path   string
	Rem    string
	To     string
	From   string
	Params map[string]string
}

PushEvent represent the current path and hash values.

@notification:event

func NewPushEvent(path string, useHash bool) (PushEvent, error)

func UseLocation(path string) PushEvent

func UseLocationHash(path string) PushEvent

func (p PushEvent) String() string

type PushEventHandler ¶

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

PushEventHandler defines a structure type which implements the PushEventSubscriber interface and the EventDistributor interface.

func NewPushEventHandler(fn func(PushEvent)) *PushEventHandler

func (sn *PushEventHandler) Handle(receive interface{})

func (sn *PushEventHandler) Receive(elem PushEvent)

type PushEventNotification ¶

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

PushEventNotification defines a structure type which must be used to receive PushEvent type has a event.

func NewPushEventNotification() *PushEventNotification

func NewPushEventNotificationWith(validation func(PushEvent) bool) *PushEventNotification

func (sn *PushEventNotification) Handle(elem interface{})

func (sn *PushEventNotification) Notify(sub PushEventSubscriber)

func (sn *PushEventNotification) UnNotify(sub PushEventSubscriber)

type PushEventSubscriber ¶

type PushEventSubscriber interface {
	Receive(PushEvent)
}

PushEventSubscriber defines a interface that which is used to subscribe specifically for events PushEvent type.

type Resolvable ¶

type Resolvable interface {
	Resolve(PushEvent)
}

Resolvable defines an interface for a resolvable type object.

type ResolveMorpher ¶

type ResolveMorpher interface {
	Resolver
	trees.Morpher
}

ResolveMorpher defines an interface for a Resolver which can morph a trees.Markup state.

type Resolver ¶

type Resolver interface {
	Resolvable

	Flush()
	Pattern() string
	Only(string, ...trees.SwitchMorpher) ResolveMorpher
	Register(Resolver)
	Done(Handler) Resolver
	Failed(Handler) Resolver
	Test(string) (map[string]string, string, bool)
}

Resolver defines an interface for a type that resolves a provided instance of a dispatch.PushEvent.

func ListenAndResolve(pattern string, fx func(PushEvent), fail func(PushEvent)) Resolver

func NewResolver(path string) Resolver

type RouteApplier ¶

type RouteApplier interface {
	Resolver
	trees.Morpher
	trees.Appliable

	Root() RouteApplier
	N(string) RouteApplier
	Next(string, trees.SwitchMorpher) RouteApplier
}

RouteApplier defines a interface which composes trees Applier, Morpher and the Resolver to handle routing over against a tree markup.

type RouteManager ¶

type RouteManager struct {
	Levels map[string]RouteApplier
}

RouteManager defines a router which handles creation and registering of a set of level connecting routes

func NewRouteManager() *RouteManager

func (r *RouteManager) L(path string) RouteApplier

func (r *RouteManager) Level(path string, morpher trees.SwitchMorpher) RouteApplier

type Router ¶

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

Router exposes a struct which describes a multi-handler of request where it

func NewRouter(handler interface{}, cache cache.Cache) *Router

func (r *Router) Cache() cache.Cache

func (r *Router) Delete(path string, params Params) (*http.Response, error)

func (r *Router) Do(method string, path string, params Params, body io.ReadCloser) (*http.Response, error)

func (r *Router) Get(path string, params Params) (*http.Response, error)

func (r *Router) Head(path string, params Params) (*http.Response, error)

func (r *Router) Options(path string, params Params) (*http.Response, error)

func (r *Router) Patch(path string, params Params, body io.ReadCloser) (*http.Response, error)

func (r *Router) Post(path string, params Params, body io.ReadCloser) (*http.Response, error)

func (r *Router) Put(path string, params Params, body io.ReadCloser) (*http.Response, error)

type Routing ¶

type Routing struct {
	Resolver
	// contains filtered or unexported fields
}

Routing defines a Resolve structure that allows morphing the output of a markup based on a giving route.

func NewRouting(path string, morpher trees.SwitchMorpher) *Routing

func (r *Routing) Apply(mr *trees.Markup)

func (r *Routing) Morph(mr *trees.Markup) *trees.Markup