ast

type Block ¶

type Block struct {
	Method     string
	Resource   string
	Alias      string
	In         []string
	Qualifiers []Qualifier
}

Block is the syntax node representing a statement.

type Chained ¶

type Chained struct {
	PathVariable string
	PathItem     string
}

Chained is the syntax node representing a chain value.

type Cloner ¶

type Cloner interface {
	Clone() interface{}
}

Cloner is implemented by any value that has a Clone method, which returns a copy of the value. This is mainly used for types which are not passed by value (e.g map, slice, chan) or structs that contain such types.

This is used in conjunction with the global state feature to create proper copies of the state to allow the parser to properly restore the state in the case of backtracking.

type DependsOnValue ¶

type DependsOnValue string

DependsOnValue is the syntax node representing the value in the `depends-on` clause.

type Filter ¶

type Filter struct {
	Field     []string
	Functions []interface{}
}

Filter is the syntax node representing entries in the `only` clause.

type FilterByRegex ¶

type FilterByRegex struct {
	PathString   *string
	PathVariable *string

	RegexString   *string
	RegexVariable *string
}

FilterByRegex is the syntax node representing the `filterByRegex` function.

type Generator ¶

type Generator struct{}

Generator encapsulate the parsing implementation used to transform a query string into an AST.

func New() (Generator, error)

func (g Generator) Parse(query string) (*Query, error)

type HeaderItem ¶

type HeaderItem struct {
	Key   string
	Value HeaderValue
}

HeaderItem is the syntax node representing an entry of the `headers` clause.

type HeaderValue ¶

type HeaderValue struct {
	Variable *string
	String   *string
	Chain    []Chained
}

HeaderValue is the syntax node representing a `headers` clause entry value.

type KeyValue ¶

type KeyValue struct {
	Key       string
	Value     Value
	Functions []string
}

KeyValue is the syntax node representing parameters in the `with` clause.

type Match ¶

type Match struct {
	String   *string
	Variable *string
}

Match is the syntax node representing the `matches` function.

type MaxAgeValue ¶

type MaxAgeValue variableOrInt

MaxAgeValue is the syntax node representing the value in the `max-age` clause.

type ObjectEntry ¶

type ObjectEntry struct {
	Key   string
	Value Value
}

ObjectEntry is the syntax node representing an object value.

type Option ¶

type Option func(*parser) Option

Option is a function that can set an option on the parser. It returns the previous setting as an Option.

func AllowInvalidUTF8(b bool) Option

func Debug(b bool) Option

func Entrypoint(ruleName string) Option

func GlobalStore(key string, value interface{}) Option

func InitState(key string, value interface{}) Option

func MaxExpressions(maxExprCnt uint64) Option

func Memoize(b bool) Option

func Recover(b bool) Option

func Statistics(stats *Stats, choiceNoMatch string) Option

input := "input"
stats := Stats{}
_, err := Parse("input-file", []byte(input), Statistics(&stats, "no match"))
if err != nil {
    log.Panicln(err)
}
b, err := json.MarshalIndent(stats.ChoiceAltCnt, "", "  ")
if err != nil {
    log.Panicln(err)
}
fmt.Println(string(b))

type ParameterBody ¶

type ParameterBody struct {
	Target    string
	Functions []string
}

ParameterBody is the syntax node representing the dynamic body feature of the `with` clause.

type Parameters ¶

type Parameters struct {
	Body      *ParameterBody
	KeyValues []KeyValue
}

Parameters is the syntax node representing the `with` clause.

type Primitive ¶

type Primitive struct {
	String  *string
	Int     *int
	Float   *float64
	Boolean *bool
	Chain   []Chained
	Null    bool
}

Primitive is the syntax node representing the basic restQL value types.

type Qualifier ¶

type Qualifier struct {
	With         *Parameters
	Only         []Filter
	Headers      []HeaderItem
	DependsOn    string
	Hidden       bool
	Timeout      *TimeoutValue
	MaxAge       *MaxAgeValue
	SMaxAge      *SMaxAgeValue
	IgnoreErrors bool
}

Qualifier is the syntax node representing statement clauses: `with`, `only`, `hidden`, `headers`, `timeout` `max-age`, `s-max-age` and `ignore-errors`.

type Query ¶

type Query struct {
	Use    []Use
	Blocks []Block
}

Query is the root of the restQL AST.

type SMaxAgeValue ¶

type SMaxAgeValue variableOrInt

SMaxAgeValue is the syntax node representing the value in the `s-max-age` clause.

type Stats ¶

type Stats struct {
	// ExprCnt counts the number of expressions processed during parsing
	// This value is compared to the maximum number of expressions allowed
	// (set by the MaxExpressions option).
	ExprCnt uint64

	// ChoiceAltCnt is used to count for each ordered choice expression,
	// which alternative is used how may times.
	// These numbers allow to optimize the order of the ordered choice expression
	// to increase the performance of the parser
	//
	// The outer key of ChoiceAltCnt is composed of the name of the rule as well
	// as the line and the column of the ordered choice.
	// The inner key of ChoiceAltCnt is the number (one-based) of the matching alternative.
	// For each alternative the number of matches are counted. If an ordered choice does not
	// match, a special counter is incremented. The name of this counter is set with
	// the parser option Statistics.
	// For an alternative to be included in ChoiceAltCnt, it has to match at least once.
	ChoiceAltCnt map[string]map[string]int
}

Stats stores some statistics, gathered during parsing

type TimeoutValue ¶

type TimeoutValue variableOrInt

TimeoutValue is the syntax node representing the value in the `timeout` clause.

type Use ¶

type Use struct {
	Key   string
	Value UseValue
}

Use is the syntax node representing the `use` clause.

type UseValue ¶

type UseValue struct {
	Int    *int
	String *string
}

UseValue is the syntax node representing the `use` clause possible values.

type Value ¶

type Value struct {
	List      []Value
	Object    []ObjectEntry
	Variable  *string
	Primitive *Primitive
}

Value is the syntax node representing possible types used in the `with` clause parameters.