hyperjumptech / grule-rule-engine Goto Github PK

rule X "X" {
   when 
       fact.someArray[23].stringVal == "abc" &&
       fact.someMap["56"].obj.IntValue > 100
   then
      fact.otherArray[12] = 23;
      fact.otherArray.append(45);
      fact.otherMap["abc"] = "def";
}

    when
       person.GetFriendByName("lucas").IsFemale() &&
       person.GetAddress().Contains("Hill Rd") &&
       person.GetCoupon().StartWith("hill".toUpper())
   then
       ...

    when
        Fact.s == "abc" && 
        Fact.o.c == "XYZ" &&
        Fact.a.len() > 0 && Fact.a[0] == Fact.s
    then
        Fact.a.append("ghi");

rule CompareString "Comparison two string values" salience 10 {
    when 
        "A" < "B"
    then
        Retract("CompareString");
}

Condition A --y--> Rule A
           \--n--> Rule B --y--> Rule C
                          \--n--> Rule D

rule NestedFunctionCall "Use a nested function call" : 10 {
    when
        Order.User().Name == "bob"
    then
        ....
}

rule WillPanic {
    when Num == 1
    then
        Num = 2;
        Log("this should be logged");
}

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0xcec79c]

env GOOS=linux   GOARCH=arm GOARM=7 go build -o dist/development/arm7    ./...
# github.com/hyperjumptech/grule-rule-engine/antlr/parser/grulev2
../../../go/pkg/mod/github.com/hyperjumptech/[email protected]/antlr/parser/grulev2/grulev2_parser.go:1255: constant 4026532015 overflows int
../../../go/pkg/mod/github.com/hyperjumptech/[email protected]/antlr/parser/grulev2/grulev2_parser.go:2835: constant 4034920623 overflows int

XXXXX@Vasu-Macbook ~/g/s/g/e/benchmark> go test -bench=. -benchmem
goos: darwin
goarch: amd64
pkg: github.com/hyperjumptech/grule-rule-engine/examples/benchmark
Benchmark_Grule_Execution_Engine/100_rules-12            2055945               574 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#01-12         2048078               570 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#02-12         2086953               572 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#03-12         2094231               571 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#04-12         2078065               576 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#05-12         2028356               642 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#06-12         2002248               628 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#07-12         1850121               703 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#08-12         1761343               585 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#09-12         2080953               594 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/100_rules#10-12         2082880               573 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules-12           2082183               575 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#01-12        2098585               568 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#02-12        2090640               570 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#03-12        2109938               587 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#04-12        2045216               576 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#05-12        2092534               575 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#06-12        1994415               579 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#07-12        2098788               599 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#08-12        2092808               573 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#09-12        2085716               609 ns/op             512 B/op          9 allocs/op
Benchmark_Grule_Execution_Engine/1000_rules#10-12        1864302               576 ns/op             512 B/op          9 allocs/op

Benchmark_Grule_Load_Rules/100_rules-12                    67137             17387 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#01-12                 67485             17447 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#02-12                 67332             17408 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#03-12                 67992             17436 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#04-12                 68170             17420 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#05-12                 67777             17645 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#06-12                 65100             17431 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#07-12                 67396             17396 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#08-12                 68132             17458 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#09-12                 67881             17399 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/100_rules#10-12                 67216             17523 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules-12                   66828             17823 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#01-12                69122             17581 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#02-12                67815             17425 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#03-12                67405             19681 ns/op            5070 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#04-12                48511             21222 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#05-12                67779             18999 ns/op            5070 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#06-12                56694             17691 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#07-12                69086             17641 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#08-12                51638             19401 ns/op            5070 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#09-12                58940             20498 ns/op            5071 B/op        118 allocs/op
Benchmark_Grule_Load_Rules/1000_rules#10-12                67411             19487 ns/op            5071 B/op        118 allocs/op

build rule_engine: cannot load github.com/hyperjumptech/grule-rule-engine: module github.com/hyperjumptech/grule-rule-engine@latest found (v1.2.4), but does not contain package github.com/hyperjumptech/grule-rule-engine

package main

import (
	"fmt"
	grule "github.com/hyperjumptech/grule-rule-engine"
	"time"
)

type MyFact struct {
	IntAttribute     int64
	StringAttribute  string
	BooleanAttribute bool
	FloatAttribute   float64
	TimeAttribute    time.Time
	WhatToSay        string
}

func main() {
	myFact := MyFact{
		IntAttribute:     123,
		StringAttribute:  "Some string value",
		BooleanAttribute: true,
		FloatAttribute:   1.234,
		TimeAttribute:    time.Now(),
	}

	println(myFact.GetWhatToSay("hello world"))

	dataCtx := grule.ast.NewDataContext()
	err := dataCtx.Add("MF", myFact)
	if err != nil {
		panic(err)
	}
}

func (mf *MyFact) GetWhatToSay(sentence string) string {
	return fmt.Sprintf("Let say \"%s\"", sentence)
}

module rule_engine

go 1.13
require (
     github.com/hyperjumptech/grule-rule-engine v1.2.4
)

        rule checkPersonalUserLoginPassword "check password whether robust."{
		when 
			Fact.CorpId<=0&&Fact.CheckPassWord("^1([38][0-9]|14[57]|5[^4])\d{8}$")
		then
			...
	}

time="2020-07-14T11:26:30+08:00" level=error msg="Loading rule resource : Byte array resources 256 bytes failed. Got error parsing quoted string (\"^1([38][0-9]|14[57]|5[^4])\\d{8}$\"): invalid syntax. Time take 3 ms"
panic: error were found before builder bailing out. Got error parsing quoted string ("^1([38][0-9]|14[57]|5[^4])\d{8}$"): invalid syntax

rule Reviewing "reviewing" salience 1 {
    when 
        F1.GetProgress() == 10
    then
        F1.Result = "good job";
        Complete();
}

rule Task1 "task 1" salience 0 {
    when
        F1.GetProgress() > 5 && F1.GetProgress() < 10
    then
        F1.DoJob();

}

rule Task2 "task 2" salience 0 {
     when
        F1.GetProgress() <= 5
    then
        F1.DoJob();
}

rule TakeABreak "break" salience -1 {
    when
        F1.GetProgress() == 5 
    then
        Retract("Task2");
        Retract("TakeABreak");
}

type PF1 struct {
	Progress int64
	Result   string
	builtin  ast.BuiltInFunctions
}

func (p *PF1) DoJob() {
	fmt.Println("[Pipeline Rule]", "DoJob")
	p.Progress += 1
	p.builtin.Changed("F1.GetProgress()")
}

func (p *PF1) WhichTask(task string) bool {
	fmt.Println("[Pipeline Rule]", task)
	return true
}

func (p *PF1) GetProgress() int64 {
	fmt.Println("[Pipeline Rule]", "GetProgress")
	return p.Progress
}

func pipeline_rule() {
	var (
		err  error
		ngin *engine.GruleEngine
	)

	pf1 := &PF1{}
	dataCtx := ast.NewDataContext()
	err = dataCtx.Add("F1", pf1)

	knowledgeLibrary := ast.NewKnowledgeLibrary()
	ruleBuilder := builder.NewRuleBuilder(knowledgeLibrary)

	fileRes := pkg.NewJSONResourceFromResource(pkg.NewFileResource("./rules/json_rule2.json"))
	err = ruleBuilder.BuildRuleFromResource("PipelineRules", "0.0.1", fileRes)
	knowledgeBase := knowledgeLibrary.NewKnowledgeBaseInstance("PipelineRules", "0.0.1")

	if err != nil {
		panic(err)
	}

	pf1.builtin = ast.BuiltInFunctions{
		Knowledge:     knowledgeBase,
		WorkingMemory: knowledgeBase.WorkingMemory,
		DataContext:   knowledgeBase.DataContext,
	}

	ngin = engine.NewGruleEngine()
	err = ngin.Execute(dataCtx, knowledgeBase)
	if err != nil {
		panic(err)
	}

	fmt.Println("[Pipeline Rule]", "PF1:", pf1.Result)
}

dataCtx := ast.NewDataContext()
err := dataCtx.Add("MF", myFact)
if err != nil {
	panic(err)
}
workingMemory := ast.NewWorkingMemory()
knowledgeBase := ast.NewKnowledgeBase("Tutorial", "0.0.1")
ruleBuilder := builder.NewRuleBuilder(knowledgeBase, workingMemory)

drls := `

engine := engine.NewGruleEngine()
for i := 0; i < 100000000; i++ {
	err = engine.Execute(dataCtx, knowledgeBase, workingMemory)
	if err != nil {
		panic(err)
	}
	if i%100000 == 0 {
		fmt.Println(myFact.WhatToSay)
		fmt.Println(i,myFact.WhatToSay,myFact.Int64Attribute,myFact.Abc)
	}
}
fmt.Println(myFact.WhatToSay)

type Inner struct {
	Age  int
	Name string
}

type MyFact struct {
	IntAttribute     int64
	StringAttribute  string
	BooleanAttribute bool
	FloatAttribute   float64
	TimeAttribute    time.Time
	WhatToSay        string
	Inn              Inner
}

                // return traceSetValue(objVal, path[1:], newValue)
		return traceSetValue(objVal.Addr().Interface(), path[1:], newValue)

// Initial fact
// MF.IntAttr = 1200000

rule Rule1 "Desc of Rule1" salience 0 {
	when
		MF.IntAttr >= 100000
	then
		Log("Rule1 called");
		Retract("Rule1");
}

rule Rule2 "Desc of Rule2" salience -1 {
	when
		MF.IntAttr / 500000 > 0.0
	then
		Log("Rule2 called");
		MF.IntAttr = MF.IntAttr - 500000;
}

panic: GruleEngine successfully selected rule candidate for execution after 5000 cycles, this could possibly caused by rule entry(s) that keep added into execution pool but when executed it does not change any data in context. Please evaluate your rule entries "When" and "Then" scope. You can adjust the maximum cycle using GruleEngine.MaxCycle variable.

rule testRule "set internet revenue" salience 10 {
    when
        ORDER["IntAttribute"] == 123
    then
        OUTPUT["result"] = "testResult";
        Retract("testRule");
}

line 4:9 token recognition error at: '['
line 4:24 token recognition error at: ']'
line 4:10 mismatched input '"IntAttribute"' expecting THEN
line 6:10 token recognition error at: '['
line 6:19 token recognition error at: ']'
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '"IntAttribute"'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '=='  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '123'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected 'then'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected 'OUTPUT'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '"result"'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '='  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '"testResult"'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected ';'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected 'Retract'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '('  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected '"testRule"'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected ')'  lib=grule struct=GruleParserV2Listener
ERRO[0000] GRL error, after '[salience 10 { when ORDER]' and then unexpected ';'  lib=grule struct=GruleParserV2Listener
ERRO[0000] Loading rule resource : Byte array resources 170 bytes failed. Got GRL error, after '[salience 10 { when ORDER]' and then unexpected ';'. Time take 2 ms 
panic: error were found before builder bailing out. Got GRL error, after '[salience 10 { when ORDER]' and then unexpected ';'

package main

import (
	json "encoding/json"
	"fmt"

	ast "github.com/hyperjumptech/grule-rule-engine/ast"
	builder "github.com/hyperjumptech/grule-rule-engine/builder"
	engine "github.com/hyperjumptech/grule-rule-engine/engine"
	pkg "github.com/hyperjumptech/grule-rule-engine/pkg"
)

func main() {
	// Create example JSON
	inputjson := `{
		"IntAttribute": 123,
    	"StringAttribute": "Some string value",
    	"BooleanAttribute": true,
    	"FloatAttribute": 1.234,
    	"TimeAttribute": "2020-03-11T10:00:00Z",
	}`

	// unmarshal the json into a map
	var input map[string]interface{}
	json.Unmarshal([]byte(inputjson), &input)

	// create the new Data Context
	dataCtx := ast.NewDataContext()
	// Add the input
	err := dataCtx.Add("INPUT", &input)
	if err != nil {
		panic(err)
	}
	// add an output map
	var output map[string]interface{}
	err = dataCtx.Add("OUTPUT", &output)
	if err != nil {
		panic(err)
	}

	workingMemory := ast.NewWorkingMemory()
	knowledgeBase := ast.NewKnowledgeBase("test", "1.0.0")
	ruleBuilder := builder.NewRuleBuilder(knowledgeBase, workingMemory)

	// example rules
	drls := `
		rule testRule "set internet revenue" salience 10 {
			when
				ORDER["IntAttribute"] == 123
			then
				OUTPUT["result"] = "testResult";
				Retract("testRule");
		}
	`

	byteArr := pkg.NewBytesResource([]byte(drls))
	err = ruleBuilder.BuildRuleFromResource(byteArr)
	if err != nil {
		panic(err)
	}

	engine := engine.NewGruleEngine()
	err = engine.Execute(dataCtx, knowledgeBase, workingMemory)
	if err != nil {
		panic(err)
	}

	fmt.Println(output["result"])
}

rule SpeedUp "When testcar is speeding up we keep increase the speed."  {
    when
        TestCar.SpeedUp == true && TestCar.Speed < TestCar.MaxSpeed
    then
        TestCar.Speed = TestCar.Speed + TestCar.SpeedIncrement;
		DistanceRecorder.TotalDistance = DistanceRecord.TotalDistance + TestCar.Speed;
}

tc := &TestCar{
    SpeedUp:        true,
    Speed:          0,
    MaxSpeed:       100,
    SpeedIncrement: 2,
}
dr := &DistanceRecorder{
    TotalDistance: 0,
}

tc2 := &TestCar{
    SpeedUp:        true,
    Speed:          0,
    MaxSpeed:       100,
    SpeedIncrement: 2,
}

dataContext := context.NewDataContext()
dataContext.Add("TestCar", tc)
dataContext.Add("DistanceRecorder", dr)
dataContext.Add("TestCar", tc2)

[{
    "name": "SpeedUp",
    "desc": "When testcar is speeding up we keep increase the \"speed\".",
    "salience": 10,
    "when": {
       "and": [
           {"eq": [{"obj": "TestCar.SpeedUp"}, {"const": true}]},
           {"lt": [{"obj": "TestCar.Speed"}, {"const": 10000000}]}
       ]
    },
    "then": [
        {"set": [{"obj": "TestCar.Speed"}, {"plus": [{"obj": "TestCar.Speed"}, {"obj": "TestCar.SpeedIncrement"}]}]},
        {"set": [{"obj": "DistanceRecord.TotalDistance"}, {"plus": [{"obj": "DistanceRecord.TotalDistance"}, {"obj": "TestCar.Speed"}]}]},
        {"call": ["Log", {"const": "\"Speed\" increased\n"}]}
    ]
}]

rule SpeedUp "When testcar is speeding up we keep increase the \"speed\"." salience 10 {
            when
                TestCar.SpeedUp == true && TestCar.Speed < 1e+07
            then
                TestCar.Speed = TestCar.Speed + TestCar.SpeedIncrement;
                DistanceRecord.TotalDistance = DistanceRecord.TotalDistance + TestCar.Speed;
                Log("\"Speed\" increased\n");
        }

rule SpeedUp "When testcar is speeding up we keep increase the \"speed\"." salience 10 {
    when
        TestCar.SpeedUp == true && TestCar.Speed < 10000000
    then
        TestCar.Speed = TestCar.Speed + TestCar.SpeedIncrement;
        DistanceRecord.TotalDistance = DistanceRecord.TotalDistance + TestCar.Speed;
        Log("\"Speed\" increased\n");
}

line 11:52 missing THEN at 'e'
time="2020-09-21T12:11:35+07:00" level=error msg="GRL error, after '[true && TestCar.Speed < 1]' and then unexpected '<missing >'" lib=grule struct=GruleParserV2Listener
time="2020-09-21T12:11:35+07:00" level=error msg="GRL error, after '[true && TestCar.Speed < 1]' and then unexpected 'e'" lib=grule struct=GruleParserV2Listener
time="2020-09-21T12:11:35+07:00" level=error msg="GRL error, after '[true && TestCar.Speed < 1]' and then unexpected '+'" lib=grule struct=GruleParserV2Listener
time="2020-09-21T12:11:35+07:00" level=error msg="GRL error, after '[true && TestCar.Speed < 1]' and then unexpected '07'" lib=grule struct=GruleParserV2Listener
time="2020-09-21T12:11:35+07:00" level=error msg="GRL error, after '[true && TestCar.Speed < 1]' and then unexpected 'then'" lib=grule struct=GruleParserV2Listener
time="2020-09-21T12:11:35+07:00" level=error msg="Loading rule resource : JSON Resource, underlying resource: Reader resource. Source unknown. failed. Got GRL error, after '[true && TestCar.Speed < 1]' and then unexpected 'then'. Time take 3 ms"

rule RuleOne "Some rule description." salience 10 {
    when
        !(someContext.attributeA.Match("123") &&
          someContext.attributeA.Contains("1"))
    then
        ...

rule RuleOne "Some rule description." salience 10 {
    when
        someContext.attributeA.Match("123")==false ||
        someContext.attributeA.Contains("1")==false
    then
        ...

rule  <rule_name> <rule_description>
   <attribute> <value> {
   when
      <conditions>

   then
      <actions>
}

rule  <rule_name> <rule_description>
   <attribute> <value> {
   when
      <conditions>

   then
      <some actions>;
      // Create some new structs in Golang
      // Store (i.e. insert) those new data strcuts into database (e.g. PostgreSQL)
     <some actions>
}

rule TestOverspeed "Check if the car overspeed."  {
    when
        TestCar.Speed > TestCar.MaxSpeed
    then
        // 1. Create a new data struct in Golang, like
        //      type CarOverspeed struct {
        //              Speed int64
        //              Location string
        //              PlateNumber string
        //       }
        // 2. Store the details of the car: speed, location, plate number,
        // 3. and then insert the struct to PostgreSQL use orm or other skill
        //
        // Above steps mean we may do some operations with `TestCar` as an
        // argument rather manipulate `TestCar` itself.
}

2020/06/04 21:33:15 Got error GruleEngine successfully selected rule candidate for execution after 1 cycles, this could possibly caused by rule entry(s) that keep added into execution pool but when executed it does not change any data in context. Please evaluate your rule entries "When" and "Then" scope. You can adjust the maximum cycle using GruleEngine.MaxCycle variable.

rule CheckValues "Check the default values" salience 10 {
    when 
        MF.IntAttribute == 123 && MF.StringAttribute == "Some string value"
    then
        MF.WhatToSay = MF.GetWhatToSay("Hello Grule");
        Retract("CheckValues");
}

package main
 
import (
    "fmt"
 
    "github.com/hyperjumptech/grule-rule-engine/ast"
    "github.com/hyperjumptech/grule-rule-engine/builder"
    "github.com/hyperjumptech/grule-rule-engine/pkg"
)
 
func main() {
    knowledgeLibrary := ast.NewKnowledgeLibrary()
    ruleBuilder      := builder.NewRuleBuilder(knowledgeLibrary)
    bundle := pkg.NewFileResourceBundle("C:\\rules", "C:\\rules\\*.grl")
    resources := bundle.MustLoad()
    fmt.Printf("resources = %v", resources)
    for _, res := range resources {
        err := ruleBuilder.BuildRuleFromResource("TutorialRules", "0.0.1", res)
        if err != nil {
            panic(err)
        }
    }
}

resources = []

resources = [File resource at C:\\rules\\1.grl]