Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Match ¶
type Match struct {
// The segments in the input corresponding to parameterized segments in Path.
Params map[string]string
// The trailing segments from the input. Note that the leading slash from the
// trailing segments is not included, since it's implied.
//
// An exception to this leading slash rule is made if the Path was constructed
// as New("*"), in which case Trailing will be identical to the inputted
// string.
Trailing string
}
Match represents the data extracted by matching an input against a Path.
To construct instances of Match, see the Match method on Path.
Example ¶
path := New("users/:id/files/*")
match, ok := path.Match("users/123/files/foo/bar/baz.txt")
fmt.Println(ok)
fmt.Println(match.Params)
fmt.Println(match.Trailing)
Output: true map[id:123] foo/bar/baz.txt
type Path ¶
type Path struct {
// A sequence of constraints on what valid segments must look like.
Segments []Segment
// Whether additional, trailing segments after Segments are acceptable.
Trailing bool
}
Path is a representation of a sequence of segments.
To construct instances of Path, see New.
func New ¶
New constructs a new Path from its human-readable string representation.
The syntax for paths looks something like the following:
/shelves/:shelf/books/:book
This would match inputs like:
/shelves/foo/books/bar /shelves/123/books/456 /shelves/123/books/ /shelves//books/456 /shelves//books/
But not any of the following:
/shelves/foo/books /shelves/foo/books/bar/ /shelves/foo/books/bar/pages/baz /SHELVES/foo/books/bar shelves/foo/books/bar
Optionally, a path can allow for "trailing" segments in the input. This is done using a segment simply named "*". For example, this path:
/users/:user/files/*
Would match inputs like:
/users/foo/files/ /users/foo/files/foo/bar/baz.txt /users/foo/files////
But not:
/users/foo /users/foo/files
The asterisk syntax for trailing segments only takes effect on the last segment. If an asterisk appears in any other segment, it carries no special meaning.
In more formal terms, the string representation of a path is a sequence of segments separated by slashes. Segments starting with colon (":") are treated as "parameter" segments (see Match).
If the final segment is just the character asterisk ("*"), it is treated as an indication that the path accepts trailing segments, and not included in the Segments of the return value. Instead, Trailing in the return value is marked as true.
Example ¶
path := New("users/:id/files/*")
fmt.Println(path.Segments[0].Const)
fmt.Println(path.Segments[1].Param)
fmt.Println(path.Segments[2].Const)
fmt.Println(path.Trailing)
Output: users id files true
func (*Path) Build ¶
Build is the inverse of Match. Given parameter and trailing segment information, Build returns a string which satifies this information.
The second parameter indicates whether the inputted match has the parameters the path specifies. If any of the parameters in the path are not found in the provided Match's Params, then false is returned.
Example ¶
path := New("users/:id/files/*")
built, ok := path.Build(Match{
Params: map[string]string{"id": "123"},
Trailing: "foo/bar/baz.txt",
})
fmt.Println(ok)
fmt.Println(built)
Output: true users/123/files/foo/bar/baz.txt
func (*Path) Match ¶
Match checks if the input string satisfies a Path's constraints, and returns parameter and trailing segment information.
The second return value indicates whether the inputted string matched the path. The first return value is meaningful only if the match was successful.
If the match was a success, all parameterized segments in Path have a corresponding entry in the Params of Match. If the path allows for trailing segments in the input, these will be in Trailing.
Source Files