rule_engine

README

exapmle

{{fieldA}} >= 10 and
{{filedA}} <= ({{fieldB}} + 5) * 2.5 and
{{fieldA}} % 1000 == 0

len({{fieldS}}) <= 40 and
regexMatch("^\s*http(s)?://.*shopee\.com", {{fieldS}})

{{fildC}} >= 100 if upper({{ENV}}) == "LIVE" else true

upper({{ENV}}) != "LIVE" or {{fildC}} >= 100

支持运算符：

类型:      bool string int float
外部传值:   {{var_name}}
括号:      ( )
单目运算符: - ! not
算数运算符: + - * / %
比较运算符: > >= < <= == !=
逻辑运算符: and && or ||
函数操作:  len min max abs regexMatch lower upper
三目运算符: x if c else y

BNF of ruleengine

top :
    TRANSLATION_UNIT

TRANSLATION_UNIT :
    LOGIC_EXPR END

LOGIC_EXPR :
    LOGIC_OR_EXPR

LOGIC_OR_EXPR :
    LOGIC_AND_EXPR
    | LOGIC_OR_EXPR OR LOGIC_AND_EXPR

LOGIC_AND_EXPR :
    THIRD_OPER_EXPR
    | LOGIC_AND_EXPR AND THIRD_OPER_EXPR

THIRD_OPER_EXPR :
    EQUAL_EXPR
    | EQUAL_EXPR IF THIRD_OPER_EXPR ELSE THIRD_OPER_EXPR

EQUAL_EXPR :
    RELATION_EXPR
    | EQUAL_EXPR EQ RELATION_EXPR
    | EQUAL_EXPR NE RELATION_EXPR

RELATION_EXPR :
    ADD_EXPR
    | ADD_EXPR '<' RELATION_EXPR
    | ADD_EXPR '>' RELATION_EXPR
    | ADD_EXPR LE RELATION_EXPR
    | ADD_EXPR GE RELATION_EXPR

ADD_EXPR :
    MUL_EXPR
    | MUL_EXPR '+' ADD_EXPR
    | MUL_EXPR '-' ADD_EXPR

MUL_EXPR :
    UNARY_EXPR
    | UNARY_EXPR '*' MUL_EXPR
    | UNARY_EXPR '/' MUL_EXPR
    | UNARY_EXPR '%' MUL_EXPR

UNARY_EXPR :
    POST_EXPR
    | '-' PRIMARY_EXPR
    | NOT PRIMARY_EXPR

POST_EXPR :
    PRIMARY_EXPR
    | IDENTIFIER '(' ARGUMENT_EXPRSSION_LIST ')'
    | IDENTIFIER '(' ')'

ARGUMENT_EXPRSSION_LIST :
    LOGIC_EXPR
    | ARGUMENT_EXPRSSION_LIST ',' LOGIC_EXPR

PRIMARY_EXPR :
    INTEGER
    | FLOAT
    | BOOL
    | STRING
    | ERROR
    | '(' LOGIC_EXPR ')'
    | VALUE_EXPR

VALUE_EXPR :
    IDLEFT VAR_NAME IDRIGHT

VAR_NAME :
    IDENTIFIER
    | VAR_NAME '.' IDENTIFIER
    | VAR_NAME '.' INTEGER

Documentation

Index

• Constants
• Variables
• type EngineErr
  • func (t *EngineErr) Error() string
• type OPER_TYPE
• type Param
  • func GetParam(key string, valueType ValueType, value interface{}) *Param
• type RuleEngineLex
  • func NewRuleEngineLex(str string, params []*Param) (*RuleEngineLex, error)
  • func (lex *RuleEngineLex) Error(s string)
  • func (lex *RuleEngineLex) Lex(lval *ruleEngineSymType) int
• type TokenNode
  • func Parse(str string, params []*Param) (*TokenNode, error)
  • func (t *TokenNode) CheckValue(v interface{}) bool
  • func (t *TokenNode) GetValue() interface{}
• type TokenRule
• type ValueType

Constants

const (
	Success = iota
	ErrRuleEngineFuncArgument
	ErrRuleEngineUnkonwnFunc
	ErrRuleEngineRegexMatch
	ErrRuleEngineNotSupportedVarType
	ErrRuleEngineSyntaxError
	ErrRuleEngineDivideByZero
	ErrRuleEngineUnknownVarName
	ErrRuleEngineInvalidVarType
	ErrRuleEngineUnknownOperator
	ErrRuleEngineNotSupportedOperator
	ErrRuleEngineInvalidOperation
)

const AND = 57355

const BOOL = 57352

const E = `([Ee][+-]?[0-9]+)`

const ELSE = 57365

const END = 57363

const EQ = 57360

const ERROR = 57362

const FALSE = 57354

const FLOAT = 57347

const FS = `(f|F|l|L)`

const GE = 57359

const H = `[a-fA-F0-9]`

const IDENTIFIER = 57351

const IDLEFT = 57349

const IDRIGHT = 57350

const IF = 57364

const INTEGER = 57346

const IS = `((u|U)|(u|U)?(l|L|ll|LL)|(l|L|ll|LL)(u|U))`

const L = `[a-zA-Z_]`

const LE = 57358

const NE = 57361

const NOT = 57357

const OR = 57356

const P = `([Pp][+-]?[0-9]+)`

const STRING = 57348

const TRUE = 57353

Variables

var KEY_WORD_LIST = [...]TokenRule{
	{AND, "AND"},
	{AND, "[A|a]nd"},
	{OR, "OR"},
	{OR, "[o|O]r"},
	{NOT, "[N|n]ot"},
	{NOT, "NOT"},
	{TRUE, "TRUE"},
	{TRUE, "[T|t]rue"},
	{FALSE, "FALSE"},
	{FALSE, "[F|f]alse"},
	{IF, "[I|i]f"},
	{IF, "IF"},
	{ELSE, "[E|e]lse"},
	{ELSE, "ELSE"},
}

var OPER_VALID_TYPE = map[OPER_TYPE][]ValueType{
	OPER_TYPE_MATH:     {ValueTypeInteger, ValueTypeFloat},
	OPER_TYPE_MOD:      {ValueTypeInteger},
	OPER_TYPE_MINUS:    {ValueTypeInteger, ValueTypeFloat},
	OPER_TYPE_RELATION: {ValueTypeInteger, ValueTypeFloat},
	OPER_TYPE_EQUAL:    {ValueTypeInteger, ValueTypeFloat, ValueTypeBool, ValueTypeString},
	OPER_TYPE_LOGIC:    {ValueTypeBool},
	OPER_TYPE_STRING:   {ValueTypeString},
	OPER_TYPE_ARGUMENT: {ValueTypeArgs},
	OPER_TYPE_REGEX:    {ValueTypeString},
}

var TOKEN_RULE_LIST = [...]TokenRule{
	{LE, "<="},
	{GE, ">="},
	{EQ, "=="},
	{NE, "!="},
	{AND, "&&"},
	{NOT, "!"},
	{OR, `\|\|`},
	{IDLEFT, "{{"},
	{IDRIGHT, "}}"},
	{STRING, `\"(\\.|[^\\"\n])*\"`},
	{STRING, `\'(\\.|[^\\'\n])*\'`},
	{FLOAT, fmt.Sprintf(`[0-9]+%v%v?`, E, FS)},
	{FLOAT, fmt.Sprintf(`[0-9]+\.[0-9]+%v?%v?`, E, FS)},
	{FLOAT, fmt.Sprintf(`[0-9]+\.[0-9]*%v?%v?`, E, FS)},
	{INTEGER, fmt.Sprintf(`0[xX]%v+%v?`, H, IS)},
	{INTEGER, fmt.Sprintf(`0[0-7]*%v?`, IS)},
	{INTEGER, fmt.Sprintf(`[1-9][0-9]*%v?`, IS)},
	{IDENTIFIER, fmt.Sprintf(`%v(%v|[0-9])*`, L, L)},
}

var VALID_CHAR_SET = map[rune]struct{}{
	'(': {},
	')': {},
	'+': {},
	'-': {},
	'*': {},
	'/': {},
	'%': {},
	'>': {},
	'<': {},
	',': {},
	'.': {},
}

var VALUE_TOKEN_TO_VALUE_TYPE = map[int]ValueType{
	INTEGER:    ValueTypeInteger,
	FLOAT:      ValueTypeFloat,
	STRING:     ValueTypeString,
	TRUE:       ValueTypeBool,
	FALSE:      ValueTypeBool,
	BOOL:       ValueTypeBool,
	IDENTIFIER: ValueTypeString,
}

var VALUE_TYPE_NAME_DICT = map[ValueType]string{
	ValueTypeBool:    "bool",
	ValueTypeFloat:   "float",
	ValueTypeString:  "string",
	ValueTypeInteger: "integer",
	ValueTypeArgs:    "args",
}

Types

type EngineErr

type EngineErr struct {
	ErrCode int
	ErrMsg  string
}

func (*EngineErr) Error

func (t *EngineErr) Error() string

type OPER_TYPE

type OPER_TYPE int

const (
	OPER_TYPE_MATH OPER_TYPE = 1 + iota
	OPER_TYPE_MOD
	OPER_TYPE_MINUS
	OPER_TYPE_RELATION
	OPER_TYPE_EQUAL
	OPER_TYPE_LOGIC
	OPER_TYPE_STRING
	OPER_TYPE_ARGUMENT
	OPER_TYPE_REGEX
)

type Param

type Param struct {
	Key   string
	Type  ValueType
	Value interface{}
}

func GetParam

func GetParam(key string, valueType ValueType, value interface{}) *Param

type RuleEngineLex

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

func NewRuleEngineLex

func NewRuleEngineLex(str string, params []*Param) (*RuleEngineLex, error)

func (*RuleEngineLex) Error

func (lex *RuleEngineLex) Error(s string)

func (*RuleEngineLex) Lex

func (lex *RuleEngineLex) Lex(lval *ruleEngineSymType) int

type TokenNode

type TokenNode struct {
	ValueType ValueType
	Value     interface{}
}

func Parse

func Parse(str string, params []*Param) (*TokenNode, error)

func (*TokenNode) CheckValue

func (t *TokenNode) CheckValue(v interface{}) bool

func (*TokenNode) GetValue

func (t *TokenNode) GetValue() interface{}

type TokenRule

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

type ValueType

type ValueType int

const (
	ValueTypeInteger ValueType = iota + 1
	ValueTypeFloat
	ValueTypeBool
	ValueTypeString
	ValueTypeArgs
)