mixer

README

Mixer

A router built specifically to power Message to Message routes.

Documentation

Index

• Constants
• Variables
• type Handler
• type HandlerFunc
  • func (h HandlerFunc) Handle(message *sabuhp.Message) (*sabuhp.Message, error)
• type InsertOption
  • func WithData(data interface{}) InsertOption
  • func WithHandler(handler Handler) InsertOption
  • func WithTag(tag string) InsertOption
  • func WithTransportResponse(handler Handler) InsertOption
• type Mux
  • func NewMux(config MuxConfig) *Mux
  • func (m *Mux) Match(target string) bool
  • func (m *Mux) Serve(route string, handler Handler)
  • func (m *Mux) ServeRoute(d *sabuhp.Message) (*sabuhp.Message, error)
• type MuxConfig
• type Node
  • func NewNode() *Node
  • func (n *Node) IsEnd() bool
  • func (n *Node) Keys(sorter NodeKeysSorter) (list []string)
  • func (n *Node) Parent() *Node
  • func (n *Node) String() string
• type NodeKeysSorter
• type ParamsSetter
• type Trie
  • func NewTrie() *Trie
  • func (t *Trie) Autocomplete(prefix string, sorter NodeKeysSorter) (list []string)
  • func (t *Trie) HasPrefix(prefix string) bool
  • func (t *Trie) Insert(pattern string, options ...InsertOption)
  • func (t *Trie) Parents(prefix string) (parents []*Node)
  • func (t *Trie) Search(q string, params ParamsSetter) *Node
  • func (t *Trie) SearchPrefix(prefix string) *Node

Constants

const (
	// ParamStart is the character, as a string, which a path pattern starts to define its named parameter.
	ParamStart = ":"

	// WildcardParamStart is the character, as a string,
	// which a path pattern starts to define its named parameter for wildcards.
	// It allows everything else after that path prefix
	// but the Trie checks for static paths and named parameters before that in order
	// to support everything that other implementations do not,
	// and if nothing else found then it tries to find the closest wildcard path(super and unique).
	WildcardParamStart = "*"
)

Variables

var DefaultKeysSorter = func(list []string) func(i, j int) bool {
	return func(i, j int) bool {
		return len(strings.Split(list[i], pathSep)) < len(strings.Split(list[j], pathSep))
	}
}

DefaultKeysSorter sorts as: first the "key (the path)" with the lowest number of slashes.

Types

type Handler

type Handler interface {
	Handle(message *sabuhp.Message) (*sabuhp.Message, error)
}

type HandlerFunc

type HandlerFunc func(message *sabuhp.Message) (*sabuhp.Message, error)

func (HandlerFunc) Handle

func (h HandlerFunc) Handle(message *sabuhp.Message) (*sabuhp.Message, error)

type InsertOption

type InsertOption func(*Node)

InsertOption is just a function which accepts a pointer to a Node which can alt its `Handler`, `Tag` and `Data` fields.

See `WithTransportResponse`, `WithTag` and `WithData`.

func WithData

func WithData(data interface{}) InsertOption

WithData sets the node's optionally `Data` field.

func WithHandler

func WithHandler(handler Handler) InsertOption

WithHandler sets the node's `Handler` field (useful for HTTP).

func WithTag

func WithTag(tag string) InsertOption

WithTag sets the node's `Tag` field (may be useful for HTTP).

func WithTransportResponse

func WithTransportResponse(handler Handler) InsertOption

WithTransportResponse sets the node's `Handler` field (useful for HTTP).

type Mux

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

Mux is Request multiplexer. It matches an event name or http url pattern to a specific TransportHandler which will be registered to the provided transport for handling specific events.

func NewMux

func NewMux(config MuxConfig) *Mux

func (*Mux) Match

func (m *Mux) Match(target string) bool

Match implements the Matcher interface.

Allow a mux to be used as a matcher and handler elsewhere.

func (*Mux) Serve

func (m *Mux) Serve(route string, handler Handler)

func (*Mux) ServeRoute

func (m *Mux) ServeRoute(d *sabuhp.Message) (*sabuhp.Message, error)

type MuxConfig

type MuxConfig struct {
	RootPath string
	NotFound Handler
}

type Node

type Node struct {

	// insert main data relative to http and a tag for things like route names.
	Handler Handler
	Tag     string

	// other insert data.
	Data interface{}
	// contains filtered or unexported fields
}

Node is the trie's node which path patterns with their data like an HTTP handler are saved to. See `Trie` too.

func NewNode

func NewNode() *Node

NewNode returns a new, empty, Node.

func (*Node) IsEnd

func (n *Node) IsEnd() bool

IsEnd returns true if this Node is a final path, has a key.

func (*Node) Keys

func (n *Node) Keys(sorter NodeKeysSorter) (list []string)

Keys returns this node's key (if it's a final path segment) and its children's node's key. The "sorter" can be optionally used to sort the result.

func (*Node) Parent

func (n *Node) Parent() *Node

Parent returns the parent of that node, can return nil if this is the rootPath node.

func (*Node) String

func (n *Node) String() string

String returns the key, which is the path pattern for the HTTP Mux.

type NodeKeysSorter

type NodeKeysSorter = func(list []string) func(i, j int) bool

NodeKeysSorter is the type definition for the sorting logic that caller can pass on `GetKeys` and `Autocomplete`.

type ParamsSetter

type ParamsSetter interface {
	Set(string, string)
}

ParamsSetter is the interface which should be implemented by the params writer for `Search` in order to store the found named path parameters, if any.

type Trie

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

Trie contains the main logic for adding and searching nodes for path segments. It supports wildcard and named path parameters. Trie supports very coblex and useful path patterns for routes. The Trie checks for static paths(path without : or *) and named parameters before that in order to support everything that other implementations do not, and if nothing else found then it tries to find the closest wildcard path(super and unique).

func NewTrie

func NewTrie() *Trie

NewTrie returns a new, empty Trie. It is only useful for end-developers that want to design their own mux/router based on my trie implementation.

See `Trie`

func (*Trie) Autocomplete

func (t *Trie) Autocomplete(prefix string, sorter NodeKeysSorter) (list []string)

Autocomplete returns the keys that starts with "prefix", this is useful for custom search-engines built on top of my trie implementation.

func (*Trie) HasPrefix

func (t *Trie) HasPrefix(prefix string) bool

HasPrefix returns true if "prefix" is found inside the registered nodes.

func (*Trie) Insert

func (t *Trie) Insert(pattern string, options ...InsertOption)

Insert adds a node to the trie.

func (*Trie) Parents

func (t *Trie) Parents(prefix string) (parents []*Node)

Parents returns the list of nodes that a node with "prefix" key belongs to.

func (*Trie) Search

func (t *Trie) Search(q string, params ParamsSetter) *Node

Search is the most important part of the Trie. It will try to find the responsible node for a specific query (or a request path for HTTP endpoints).

Search supports searching for static paths(path without : or *) and paths that contain named parameters or wildcards. Priority as: 1. static paths 2. named parameters with ":" 3. wildcards 4. closest wildcard if not found, if any 5. rootPath wildcard

func (*Trie) SearchPrefix

func (t *Trie) SearchPrefix(prefix string) *Node

SearchPrefix returns the last node which holds the key which starts with "prefix".