path

Documentation

Overview

Package path implements utility routines for manipulating slash-separated paths.

Index

• Variables
• type Route
  • func NewRoute(rpath string) (rute *Route, err error)
  • func (rute *Route) IsKeyExists(key string) bool
  • func (rute *Route) Keys() (keys []string)
  • func (rute *Route) NKey() (n int)
  • func (rute *Route) Parse(rpath string) (vals map[string]string, ok bool)
  • func (rute *Route) Path() string
  • func (rute *Route) Set(key, val string) bool
  • func (rute *Route) String() (path string)

Examples

• Route.IsKeyExists
• Route.Keys
• Route.NKey
• Route.Parse
• Route.Path
• Route.Set

Variables

var ErrPathKeyDuplicate = errors.New(`duplicate key in path`)

ErrPathKeyDuplicate define an error when registering path with the same keys, for example "/:x/:x".

var ErrPathKeyEmpty = errors.New(`empty path key`)

ErrPathKeyEmpty define an error when path contains an empty key, for example "/:/y".

Types

type Route

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

Route represent a parsed path. A path can have a key, or binding, that can be replaced with string value. For example, "/org/:user/:repo" have two keys "user" and "repo".

Route handle the path in case-insensitive manner.

func NewRoute

func NewRoute(rpath string) (rute *Route, err error)

NewRoute create new Route from path. It will store the key(s) in path if available.

The key is sub-path that start with colon ":". For example, the following path "/:user/:repo" contains two sub-paths with both are keys. If path is invalid, for example, "/:user/:" or "/:user/:user" (key with duplicate names), it will return nil with an error.

func (*Route) IsKeyExists

func (rute *Route) IsKeyExists(key string) bool

IsKeyExists will return true if the key exist in Route; otherwise it will return false. Remember that the key is stored in lower case, so it will be matched after the parameter key is converted to lower case.

Example

package main

import (
	"fmt"
	"log"

	libpath "git.sr.ht/~shulhan/pakakeh.go/lib/path"
)

func main() {
	var (
		rute *libpath.Route
		err  error
	)

	rute, err = libpath.NewRoute(`/book/:title/:page`)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rute.IsKeyExists(`book`))
	fmt.Println(rute.IsKeyExists(`title`))
	fmt.Println(rute.IsKeyExists(`TITLE`))
}

Output:

false
true
true

func (*Route) Keys

func (rute *Route) Keys() (keys []string)

Keys return list of key in path.

Example

package main

import (
	"fmt"
	"log"

	libpath "git.sr.ht/~shulhan/pakakeh.go/lib/path"
)

func main() {
	var (
		rute *libpath.Route
		err  error
	)

	rute, err = libpath.NewRoute(`/book/:title/:page`)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rute.Keys())
}

Output:

[title page]

func (*Route) NKey

func (rute *Route) NKey() (n int)

NKey return the number of key in path.

Example

package main

import (
	"fmt"
	"log"

	libpath "git.sr.ht/~shulhan/pakakeh.go/lib/path"
)

func main() {
	var (
		rute *libpath.Route
		err  error
	)

	rute, err = libpath.NewRoute(`/book/:title/:page`)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rute.NKey())
}

Output:

2

func (*Route) Parse

func (rute *Route) Parse(rpath string) (vals map[string]string, ok bool)

Parse the path and return the key-value association and true if path is matched with current Route; otherwise it will return nil and false.

Example

package main

import (
	"fmt"
	"log"

	libpath "git.sr.ht/~shulhan/pakakeh.go/lib/path"
)

func main() {
	var (
		rute *libpath.Route
		err  error
	)

	rute, err = libpath.NewRoute(`/book/:title/:page`)
	if err != nil {
		log.Fatal(err)
	}

	var (
		vals map[string]string
		ok   bool
	)

	vals, ok = rute.Parse(`/book/Hitchiker to Galaxy/42`)
	fmt.Println(ok, vals)

	vals, ok = rute.Parse(`/book/Hitchiker to Galaxy`)
	fmt.Println(ok, vals)

	vals, ok = rute.Parse(`/book/Hitchiker to Galaxy/42/order`)
	fmt.Println(ok, vals)

}

Output:

true map[page:42 title:hitchiker to galaxy]
false map[]
false map[]

func (*Route) Path

func (rute *Route) Path() string

Path return the path with all the keys has been substituted with values, even if its empty. See Route.String for returning path with key name (as in ":name").

Example

package main

import (
	"fmt"
	"log"

	libpath "git.sr.ht/~shulhan/pakakeh.go/lib/path"
)

func main() {
	var (
		rute *libpath.Route
		err  error
	)

	rute, err = libpath.NewRoute(`/:user/:repo`)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rute.Path())

	rute.Set(`user`, `shuLhan`)
	fmt.Println(rute.Path())

	rute.Set(`repo`, `pakakeh.go`)
	fmt.Println(rute.Path())

}

Output:

//
/shuLhan/
/shuLhan/pakakeh.go

func (*Route) Set

func (rute *Route) Set(key, val string) bool

Set or replace the key's value in path with parameter val. If the key exist it will return true; otherwise it will return false.

Example

package main

import (
	"fmt"
	"log"

	libpath "git.sr.ht/~shulhan/pakakeh.go/lib/path"
)

func main() {
	var (
		rute *libpath.Route
		err  error
	)
	rute, err = libpath.NewRoute(`/:user/:repo`)
	if err != nil {
		log.Fatal(err)
	}

	rute.Set(`user`, `shuLhan`)
	fmt.Println(rute)

	rute.Set(`repo`, `share`)
	fmt.Println(rute)
}

Output:

/shuLhan/:repo
/shuLhan/share

func (*Route) String

func (rute *Route) String() (path string)

String generate a clean path without any white spaces and single "/" between sub-path. If the key has been Route.Set, the sub-path will be replaced with its value, otherwise it will returned as ":<key>".

To return the path with all keys has been substituted, even empty, use Route.Path.