rewrite

Documentation

Overview

Package rewrite is middleware for rewriting requests internally to a different path.

Index

• Constants
• type ComplexRule
  • func NewComplexRule(base, pattern, to string, status int, ext []string, ifs []If) (*ComplexRule, error)
  • func (r *ComplexRule) Rewrite(fs http.FileSystem, req *http.Request) (re Result)
• type If
  • func NewIf(a, operator, b string) (If, error)
  • func (i If) True(r *http.Request) bool
• type Result
  • func To(fs http.FileSystem, r *http.Request, to string, replacer middleware.Replacer) Result
• type Rewrite
  • func (rw Rewrite) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)
• type Rule
• type SimpleRule
  • func NewSimpleRule(from, to string) SimpleRule
  • func (s SimpleRule) Rewrite(fs http.FileSystem, r *http.Request) Result

Constants

const (
	Is         = "is"
	Not        = "not"
	Has        = "has"
	NotHas     = "not_has"
	StartsWith = "starts_with"
	EndsWith   = "ends_with"
	Match      = "match"
	NotMatch   = "not_match"
)

Operators

Types

type ComplexRule

type ComplexRule struct {
	// Path base. Request to this path and subpaths will be rewritten
	Base string

	// Path to rewrite to
	To string

	// If set, neither performs rewrite nor proceeds
	// with request. Only returns code.
	Status int

	// Extensions to filter by
	Exts []string

	// Rewrite conditions
	Ifs []If

	*regexp.Regexp
}

ComplexRule is a rewrite rule based on a regular expression

func NewComplexRule

func NewComplexRule(base, pattern, to string, status int, ext []string, ifs []If) (*ComplexRule, error)

NewComplexRule creates a new RegexpRule. It returns an error if regexp pattern (pattern) or extensions (ext) are invalid.

func (*ComplexRule) Rewrite

func (r *ComplexRule) Rewrite(fs http.FileSystem, req *http.Request) (re Result)

Rewrite rewrites the internal location of the current request.

type If

type If struct {
	A        string
	Operator string
	B        string
}

If is statement for a rewrite condition.

func NewIf

func NewIf(a, operator, b string) (If, error)

NewIf creates a new If condition.

func (If) True

func (i If) True(r *http.Request) bool

True returns true if the condition is true and false otherwise. If r is not nil, it replaces placeholders before comparison.

type Result

type Result int

Result is the result of a rewrite

const (
	// RewriteIgnored is returned when rewrite is not done on request.
	RewriteIgnored Result = iota
	// RewriteDone is returned when rewrite is done on request.
	RewriteDone
	// RewriteStatus is returned when rewrite is not needed and status code should be set
	// for the request.
	RewriteStatus
)

func To

func To(fs http.FileSystem, r *http.Request, to string, replacer middleware.Replacer) Result

To attempts rewrite. It attempts to rewrite to first valid path or the last path if none of the paths are valid. Returns true if rewrite is successful and false otherwise.

type Rewrite

type Rewrite struct {
	Next    middleware.Handler
	FileSys http.FileSystem
	Rules   []Rule
}

Rewrite is middleware to rewrite request locations internally before being handled.

func (Rewrite) ServeHTTP

func (rw Rewrite) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)

ServeHTTP implements the middleware.Handler interface.

type Rule

type Rule interface {
	// Rewrite rewrites the internal location of the current request.
	Rewrite(http.FileSystem, *http.Request) Result
}

Rule describes an internal location rewrite rule.

type SimpleRule

type SimpleRule struct {
	From, To string
}

SimpleRule is a simple rewrite rule.

func NewSimpleRule

func NewSimpleRule(from, to string) SimpleRule

NewSimpleRule creates a new Simple Rule

func (SimpleRule) Rewrite

func (s SimpleRule) Rewrite(fs http.FileSystem, r *http.Request) Result

Rewrite rewrites the internal location of the current request.