ruler

README

Intro

go-rule-engine是用Golang实现的小型规则引擎，可以使用json串构造子规则，以及逻辑表达式表征子规则间逻辑运算关系。也可以通过直接构造子规则对象传入，这样方便子规则的持久化和复用。

Usage

    // build rules
	jsonRules := []byte(`[
	{"op": "=", "key": "Grade", "val": 3, "id": 1, "msg": "Grade not match"},
	{"op": "=", "key": "Sex", "val": "male", "id": 2, "msg": "not male"},
	{"op": ">=", "key": "Score.Math", "val": 90, "id": 3, "msg": "Math not so well"},
	{"op": ">=", "key": "Score.Physic", "val": 90, "id": 4, "msg": "Physic not so well"}
	]`)
	logic := "1 and not 2 and (3 or 4)"
	ruleToFit, err := NewRulesWithJSONAndLogic(jsonRules, logic)
	if err != nil {
		t.Error(err)
	}

	// prepare obj
	type Exams struct {
		Math int
		Physic int
	}
	type Student struct {
		Name string
		Grade int
		Sex string
		Score *Exams
	}
	Chris := &Student{
		Name: "Chris",
		Grade: 3,
		Sex: "female",
		Score: &Exams{Math: 88, Physic: 91},
	}

	// fit
	fit, msg := ruleToFit.Fit(Chris)
	t.Log(fit)
	t.Log(msg)

	// result
	true    // fit
	map[1:Grade not match 2:not male 4:Physic not so well]   // 注意：当fit=true，msg是命中的ruleIds

	Helen := &Student{
		Name: "Helen",
		Grade: 4,
		Sex: "female",
		Score: &Exams{Math: 96, Physic: 93},
	}

	// result
	false   				// fit
	map[1:Grade not match]   // msg

概念

子规则Rule

// key支持链式表达
{"op": ">=", "key": "Score.Physic", "val": 90, "id": 4, "msg": "Physic not so well"}

// Rule 最小单元，子规则
type Rule struct {
	Op  string      `json:"op"`  // 预算符
	Key string      `json:"key"` // 目标变量键名
	Val interface{} `json:"val"` // 目标变量子规则存值
	ID  int         `json:"id"`  // 子规则ID
	Msg string      `json:"msg"` // 该规则抛出的负提示
}

逻辑表达式logic

// 数字是rule的ID，当需要所有rule都为true，可以缺省写法：logic=""
"1 and not 2 and (3 or 4)"

规则Rules

// 即创建的ruleToFit对象
ruleToFit, err := NewRulesWithJSONAndLogic(jsonRules, logic)

// Rules 规则，拥有逻辑表达式
type Rules struct {
	Rules []*Rule // 子规则集合
	Logic string  // 逻辑表达式，使用子规则ID运算表达
	Name  string  // 规则名称
	Msg   string  // 规则抛出的负提示
}

匹配结果Fit

fit, msg := ruleToFit.Fit(Chris)
t.Log(fit)

false

原因msg

fit, msg := ruleToFit.Fit(Chris)
t.Log(fit)
t.Log(msg)

false
// fit=false, 键1是导致fit为false的那个rule的ID，值是那个rule的msg字段，用于提示
map[1:Grade not match]
// 注意：若fit=true, msg则是参与导致fit为true的那些rule的IDs，这是为了表达反向逻辑的规则中的原因

API

// NewRulesWithJSONAndLogic 用json串构造Rules的标准方法，logic表达式如果没有则传空字符串
func NewRulesWithJSONAndLogic(jsonStr []byte, logic string) (*Rules, error)

// NewRulesWithArrayAndLogic 用rule数组构造Rules的标准方法，logic表达式如果没有则传空字符串
func NewRulesWithArrayAndLogic(rules []*Rule, logic string) (*Rules, error) 

// Fit Rules匹配传入结构体
func (rs *Rules) Fit(o interface{}) (bool, map[int]string) 

// FitWithMap Rules匹配map
func (rs *Rules) FitWithMap(o map[string]interface{}) (bool, map[int]string) 

// FitAskVal Rules匹配结构体，同时返回所有子规则key对应实际值
func (rs *Rules) FitAskVal(o interface{}) (bool, map[int]string, map[int]interface{}) 

// FitWithMapAskVal Rules匹配map，同时返回所有子规则key对应实际值
func (rs *Rules) FitWithMapAskVal(o map[string]interface{}) (bool, map[int]string, map[int]interface{}) 

// GetRuleIDsByLogicExpression 根据逻辑表达式得到规则id列表
func GetRuleIDsByLogicExpression(logic string) ([]int, error) 

支持的算符

// 等于
case "=", "eq":

// 大于
case ">", "gt":

// 小于		
case "<", "lt":

// 大于或等于	
case ">=", "gte":

// 小于或等于		
case "<=", "lte":

// 不等于		
case "!=", "neq":

// 取值在...之中（val用逗号,分隔取值）		
case "@", "in":

// 取值不能在...之中		
case "!@", "nin":

// 正则表达式
case "^$", "regex":

// 为空不存在
case "0", "empty":

// 不为空
case "1", "nempty":

// 区间（只支持数字比较）
// 支持开闭区间格式，val="[,12.1]", "(1, 3]", "(8, )" etc.
case "<<", "between":

支持的逻辑

// 与
and

// 或
or

// 非
not

// 括号，可嵌套
()

Documentation

Index

• Constants
• Variables
• func CheckLogicExpressionAndFormat(logic string) (string, error)
• func GetRuleIDsByLogicExpression(logic string) ([]int, error)
• type Node
• type Rule
• type Rules
  • func NewRulesWithArrayAndLogic(rules []*Rule, logic string) (*Rules, error)
  • func NewRulesWithArrayAndLogicAndInfo(rules []*Rule, logic string, extractInfo map[string]string) (*Rules, error)
  • func NewRulesWithJSONAndLogic(jsonStr []byte, logic string) (*Rules, error)
  • func NewRulesWithJSONAndLogicAndInfo(jsonStr []byte, logic string, extractInfo map[string]string) (*Rules, error)
  • func (rs *Rules) Fit(o interface{}) (bool, map[int]string)
  • func (rs *Rules) FitAskVal(o interface{}) (bool, map[int]string, map[int]interface{})
  • func (rs *Rules) FitWithMap(o map[string]interface{}) (bool, map[int]string)
  • func (rs *Rules) FitWithMapAskVal(o map[string]interface{}) (bool, map[int]string, map[int]interface{})
• type RulesList
  • func NewRulesList(listRules []*Rules, extractInfo map[string]string) *RulesList
  • func (rst *RulesList) Fit(o interface{}) *Rules
  • func (rst *RulesList) FitGetFloat64(o interface{}) (bool, float64)
  • func (rst *RulesList) FitGetInt64(o interface{}) (bool, int64)
  • func (rst *RulesList) FitGetStr(o interface{}) (bool, string)
  • func (rst *RulesList) FitWithMap(o map[string]interface{}) *Rules

Constants

const (
	// OperatorAnd and
	OperatorAnd operator = "and"
	// OperatorOr or
	OperatorOr operator = "or"
	// OperatorNot not
	OperatorNot operator = "not"
)

const EmptyFloat64 = 0

EmptyFloat64 空数字

const EmptyStr = ""

EmptyStr 空串

const PatternNumber = "^\\d*$"

PatternNumber 纯数字的正则表达式

const Space = " "

Space 空格

Variables

var ValidAtomOperatorsDisplay = []string{"=", ">", "<", ">=", "<=", "!=", "in", "nin", "regex", "empty", "nempty", "between", "intersect"}

ValidAtomOperatorsDisplay 有效子规则运算符-展示

var ValidOperators = []string{"and", "or", "not"}

ValidOperators 有效逻辑运算符

Functions

func CheckLogicExpressionAndFormat

func CheckLogicExpressionAndFormat(logic string) (string, error)

CheckLogicExpressionAndFormat 检查逻辑表达式正确性，并返回formatted

func GetRuleIDsByLogicExpression

func GetRuleIDsByLogicExpression(logic string) ([]int, error)

GetRuleIDsByLogicExpression 根据逻辑表达式得到规则id列表

Types

type Node

type Node struct {
	Expr       string  // 分割的logic表达式
	ChildrenOp string  // 孩子树之间的运算符: and, or, not
	Val        bool    // 节点值
	Computed   bool    // 节点值被计算过
	Leaf       bool    // 是否叶子节点
	Should     bool    // 为了Fit为true，此节点必须的值
	Blamed     bool    // 此节点为了Fit为true，有责任必须为某值
	Children   []*Node // 孩子树
}

Node 树节点

type Rule

type Rule struct {
	Op  string      `json:"op"`  // 算符
	Key string      `json:"key"` // 目标变量键名
	Val interface{} `json:"val"` // 目标变量子规则存值
	ID  int         `json:"id"`  // 子规则ID
	Msg string      `json:"msg"` // 该规则抛出的负提示
}

Rule 最小单元，子规则

type Rules

type Rules struct {
	Rules []*Rule     // 子规则集合
	Logic string      // 逻辑表达式，使用子规则ID运算表达
	Name  string      // 规则名称
	Msg   string      // 规则抛出的负提示
	Val   interface{} // 改规则所代表的存值
}

Rules 规则，拥有逻辑表达式

func NewRulesWithArrayAndLogic

func NewRulesWithArrayAndLogic(rules []*Rule, logic string) (*Rules, error)

NewRulesWithArrayAndLogic 用rule数组构造Rules的标准方法，logic表达式如果没有则传空字符串

func NewRulesWithArrayAndLogicAndInfo

func NewRulesWithArrayAndLogicAndInfo(rules []*Rule, logic string, extractInfo map[string]string) (*Rules, error)

NewRulesWithArrayAndLogicAndInfo 用rule数组构造Rules的完全方法，logic表达式如果没有则传空字符串, ["name": "规则名称", "msg": "规则不符合的提示"]

func NewRulesWithJSONAndLogic

func NewRulesWithJSONAndLogic(jsonStr []byte, logic string) (*Rules, error)

NewRulesWithJSONAndLogic 用json串构造Rules的标准方法，logic表达式如果没有则传空字符串

func NewRulesWithJSONAndLogicAndInfo

func NewRulesWithJSONAndLogicAndInfo(jsonStr []byte, logic string, extractInfo map[string]string) (*Rules, error)

NewRulesWithJSONAndLogicAndInfo 用json串构造Rules的完全方法，logic表达式如果没有则传空字符串, ["name": "规则名称", "msg": "规则不符合的提示"]

func (*Rules) Fit

func (rs *Rules) Fit(o interface{}) (bool, map[int]string)

Fit Rules匹配传入结构体

func (*Rules) FitAskVal

func (rs *Rules) FitAskVal(o interface{}) (bool, map[int]string, map[int]interface{})

FitAskVal Rules匹配结构体，同时返回所有子规则key值

func (*Rules) FitWithMap

func (rs *Rules) FitWithMap(o map[string]interface{}) (bool, map[int]string)

FitWithMap Rules匹配map

func (*Rules) FitWithMapAskVal

func (rs *Rules) FitWithMapAskVal(o map[string]interface{}) (bool, map[int]string, map[int]interface{})

FitWithMapAskVal Rules匹配map，同时返回所有子规则key值

type RulesList

type RulesList struct {
	RulesList []*Rules
	Name      string
	Msg       string
}

RulesList 规则组，顺序即优先级

func NewRulesList

func NewRulesList(listRules []*Rules, extractInfo map[string]string) *RulesList

NewRulesList RulesList的构造方法，["name": "规则集的名称", "msg": "规则集的简述"]

func (*RulesList) Fit

func (rst *RulesList) Fit(o interface{}) *Rules

Fit RulesList's fit, means hitting first rules in array

func (*RulesList) FitGetFloat64

func (rst *RulesList) FitGetFloat64(o interface{}) (bool, float64)

FitGetFloat64 return hit value, float64

func (*RulesList) FitGetInt64

func (rst *RulesList) FitGetInt64(o interface{}) (bool, int64)

FitGetInt64 return hit value, int64

func (*RulesList) FitGetStr

func (rst *RulesList) FitGetStr(o interface{}) (bool, string)

FitGetStr return hit rules value, string

func (*RulesList) FitWithMap

func (rst *RulesList) FitWithMap(o map[string]interface{}) *Rules

FitWithMap RulesList's fit, means hitting first rules in array