parser

type AssertToFunc ¶

type AssertToFunc func(E) error

type E ¶

type E interface {
	Value() interface{}
	ToAssert(ats []*strategy.Archetype) (AssertToFunc, error)
}

Elements can be turned into assert functions that can test wether an other elements meet the exptation(s)

type Element ¶

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

Element represents a value in a table that can converted to an assert

func NewElement(val interface{}) *Element

func (example *Element) ToAssert(ats []*strategy.Archetype) (AssertToFunc, error)

func (e *Element) Value() interface{}

type JSON ¶

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

For parsing byte arrays that are known to be JSON encoded

func NewJSON(ats []*strategy.Archetype) *JSON

func (p *JSON) Parse(data []byte) (T, error)

type JSONT ¶

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

A table of values that are mapped using json paths (e.g 0.name.full_name)

func (t *JSONT) All() map[string]E

func (t *JSONT) Follows(ex T) error

func (t *JSONT) Get(key string) E

func (t *JSONT) Set(key string, e E)

type P ¶

type P interface {
	Parse([]byte) (T, error)
}

Parsers turn bytes into a linear Table of comparable elements

type Plain ¶

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

For parsing byte arrays that just hold plain text but will ignore trailing whitespace as defined by unicode

func NewPlain(ats []*strategy.Archetype) *Plain

func (p *Plain) Parse(data []byte) (T, error)

type PlainT ¶

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

A table that should only contain the single plain text value

func (t *PlainT) All() map[string]E

func (t *PlainT) Follows(ex T) error

func (t *PlainT) Get(key string) E

func (t *PlainT) Set(key string, e E)

type T ¶

type T interface {
	All() map[string]E
	Set(string, E)
	Get(string) E

	Follows(T) error
}

Tables are compared against other tables