parser

type CloseResponse struct {
	UnclosedBrackets models.Rune
	Error            error
}

type Command struct {
	Type           CommandType
	Path           []string
	Name           string
	ExecFunc       ExecFunc
	SystemExecFunc SystemExecFunc
	OutFunc        OutFunc
	Flags          Flags
	Options        Options
	MandatoryFlags []string
	// contains filtered or unexported fields
}

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

type CommandType string

type CompleteOption struct {
	Level  LevelType
	Option string
}

type CompleteResponse struct {
	Options []*CompleteOption
	Merged  string
}

type Context interface {
	context.Context
	Buffer() terminal.Buffer
}

type ContextType int

type ExecFunc func(Context, FlagValues, Options) (Value, error)

type ExecResponse struct {
	UnclosedBrackets models.Rune
	Error            error
	Value            Value
}

type Expression interface {
	Valuer
	Type() ExpressionType
	Add(ctx SystemContext, r models.Rune) *Response
	Complete(ctx SystemContext) *CompleteResponse
	Close(ctx SystemContext) *CloseResponse
}

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

type ExpressionType string

type Flag struct {
	Name      string
	Mandatory bool
	Number    uint
	ValueType
	// contains filtered or unexported fields
}

type FlagValues map[string]Value

type Flags map[string]*Flag

type Item struct {
	Level    LevelType
	Payload  interface{}
	Children map[string]*Item
}

type LevelType int

type List struct {
	Commands []*Command
}

type MathState int

type MockExpression struct {
	mock.Mock
}

type MockTestExec struct {
	mock.Mock
}

type NextOption struct {
	Name  string
	Level LevelType
}

type NextOptions struct {
	AggregatedLevel LevelType
	Options         []*NextOption
	Merged          string
}

type Object int

type Operator int

type Option struct {
	Name string
}

type Options map[string]bool

type OutFunc func(SystemContext, Flags, Options)

type ParseRuneResponse struct {
	Object Object
}

type ParseStringResponse struct {
	Objects []*ParsedObject
	Error   error
}

type ParsedObject struct {
	Object Object
	Length int
}

type Parser interface {
	Flush()
	IsFlushed() bool
	Add(r models.Rune) (*ParseRuneResponse, error)
	ParseString(s string) *ParseStringResponse
	Exec() (*ExecResponse, error)
	Continue() *CompleteResponse
}

type Payload struct {
	Level    LevelType
	Value    string
	NextTree *CommandTree
	Payload  interface{}
}

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

type ResponseAction int

type ResponseType string

type Result struct {
	Message string
}

type StateCommand int

type SystemContext interface {
	Context
	CommandTree() *CommandTree
	SetCommandTree(commandTree *CommandTree)
	CommandRoot() *CommandTree
	SetCommandRoot(commandRoot *CommandTree)
	VariableTree() *VariableTree
	GetVariablePayload(name string) interface{}
	VariableExists(name string) bool
	GetVariable(name string) Value
	SetGlobalVariable(name string, value interface{})
	SetLocalVariable(name string, value interface{})
	Ctx() context.Context
	WithContext(ctx context.Context) SystemContext
	New() SystemContext
	Copy() SystemContext
	Logger() logger.Logger
}

type SystemExecFunc func(SystemContext, Flags, Options) (Value, error)

type TestExec interface {
	Exec(ctx Context, flags FlagValues, options Options) (Value, error)
}

type Value interface {
	Bool() bool
	Number() int
	String() string

	IsBool() bool
	IsString() bool
	IsNumber() bool

	Equal(v Value) bool
	Less(v Value) bool
	Greater(v Value) bool
}

type ValueType int

type Valuer interface {
	Value(ctx SystemContext) Value
}

type VariableState int

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