pattern

func (Binds) All ¶

func (bs Binds) All(key string) []string

All returns all the bound values of key in bs, in order of occurrence.

func (Binds) First ¶

func (bs Binds) First(key string) string

First returns the first bound value of key in bs, in order of occurrence. It returns "" if key is not bound.

func (Binds) Has ¶

func (bs Binds) Has(key string) bool

Has reports whether key is bound at least once in bs.

func (*P) Apply ¶

func (p *P) Apply(binds []Bind) (string, error)

Apply applies a list of bindings to the pattern template to produce a new string. It is an error if the bindings do not cover the pattern words in the template, meaning binds has at least one binding for each pattern word mentioned by the template.

If a pattern word appears in the template more often than in binds, the value of the last matching binding is repeated to fill the remaining spots.

package main

import (
	"fmt"
	"log"

	"github.com/creachadair/pattern"
)

func main() {
	p := pattern.MustParse(`type ${name} struct {
  ${lhs} int
  ${rhs} int
}`, nil)

	s, err := p.Apply(pattern.Binds{
		{Name: "name", Expr: "binop"},
		{Name: "lhs", Expr: "X"},
		{Name: "rhs", Expr: "Y"},
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(s)
}

Output:

type binop struct {
  X int
  Y int
}

func (*P) ApplyFunc ¶

func (p *P) ApplyFunc(f BindFunc) (string, error)

ApplyFunc applies bindings generated by f to the pattern template of p to produce a new string. If f reports an error, application fails. ApplyFunc will panic if f == nil.

package main

import (
	"fmt"
	"log"

	"github.com/creachadair/pattern"
)

func main() {
	p := pattern.MustParse(`type ${name} struct {
  ${arg} string `+"`json:\"${arg},omitempty\"`"+`
}`, nil)

	s, err := p.ApplyFunc(func(name string, n int) (string, error) {
		if name == "name" {
			return "Argument", nil
		} else if n == 1 {
			return "X", nil
		}
		return "value", nil
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(s)
}

Output:

type Argument struct {
  X string `json:"value,omitempty"`
}

func (*P) Bind ¶

func (p *P) Bind(binds Binds) *P

Bind returns a copy of p with the specified bindings updated. Existing bindings of p not mentioned in binds are copied intact from p to the result.

func (*P) Binds ¶

func (p *P) Binds() Binds

Binds returns a list of bindings for p, in parsed order, populated with the currently-bound expression strings. Modifying the result has no effect on p, the caller may use this to generate a list of bindings to fill with values.

func (*P) Derive ¶

func (p *P) Derive(s string) (*P, error)

Derive constructs a new compiled pattern, using the same pattern words as p but with s as the template instead. It is an error if s refers to a pattern word not known to p.

func (*P) Match ¶

func (p *P) Match(needle string) (Binds, error)

Match reports whether needle matches p, and if so returns a list of bindings for the pattern words occurring in s. Because the same pattern word may occur multiple times in the pattern, the order of bindings is significant.

If matching fails, Match returns nil, ErrNoMatch. If matching succeeds but no bindings are found, Match returns nil, nil.

package main

import (
	"fmt"
	"log"

	"github.com/creachadair/pattern"
)

func main() {
	p := pattern.MustParse(`[${text}](${link})`, pattern.Binds{
		{Name: "text", Expr: ".+"},
		{Name: "link", Expr: "\\S+"},
	})

	m, err := p.Match(`[docs](http://godoc.org/net/url)`)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("link text: %s\n", m.First("text"))
	fmt.Printf("URL: %s\n", m.First("link"))

}

Output:

link text: docs
URL: http://godoc.org/net/url

func (*P) Search ¶

func (p *P) Search(needle string, f func(start, end int, binds Binds) error) error

Search scans needle for all non-overlapping matches of p. For each match, Search calls f with the starting and ending offsets of the match, along with the bindings captured from the match. If f reports an error, the search ends. If the error is ErrStopSearch, Search returns nil. Otherwise Search returns the error from f.

package main

import (
	"fmt"
	"log"

	"github.com/creachadair/pattern"
)

func main() {
	p := pattern.MustParse("${word}:", pattern.Binds{
		{Name: "word", Expr: "\\w+"},
	})

	const text = `
Do: a deer, a female deer, Re: a drop of golden sun.
Mi: a name I call myself, Fa: a long long way to run.
`
	if err := p.Search(text, func(i, j int, m pattern.Binds) error {
		fmt.Printf("At %d: %q\n", i, m.First("word"))
		return nil
	}); err != nil {
		log.Fatal(err)
	}

}

Output:

At 1: "Do"
At 28: "Re"
At 54: "Mi"
At 80: "Fa"

func (*P) String ¶

func (p *P) String() string

String returns the original template string from which p was parsed.

func (*ParseError) Error ¶

func (p *ParseError) Error() string