hooqtv/fished

Fish answers from rules and facts

fished

Migrated to https://github.coupang.net/coupang/couplay-fished

Fish answers from rules and facts

Install

$ go get -u github.com/jonathansudibya/fished

or using dep

$ dep ensure -add github.com/jonathansudibya/fished

Structs

Rule :

type Rule struct {
	Output 			string   `json:"output"`
	Input  			[]string `json:"input"`
	Expression   	string   `json:"expression"`
	...
}

Engine:

type Engine struct {
    Facts         map[string]interface{}
	Rules         []Rule
	RuleFunctions map[string]govaluate.ExpressionFunction
	Jobs          chan int
    ...
}

Example

Please see in test file especially TestRun() function.

package main

import "github.com/jonathansudibya/fished"

func main() {
	e := fished.New(nil)
	e.SetRules([]Rule{
		Rule{
			Input: []string{"hello"},
			Output: "result_end",
			Expression: "hello == 'world'",
		}
	})
	e.SetFacts = map[string]interface{}{
		"hello": "world"
	}
	res, errs := e.Run()

	fmt.Println(res) // will result true
}

Notes

Remember it is more expensive to set new rules than to set facts.

Credits

This project is powered by

• https://github.com/Knetic/govaluate. Please check if you need an arbitrary expression checker!
• https://github.com/json-iterator/go. One of (or the fastest) drop-in replacement for standart json library.
• https://github.com/stretchr/testify. A nice and clean testing library. Helping me a lot for better test results.

LICENSE

See LICENSE.md

fished's Issues

A more complex test

Fine work boss @JonathanSudibya. Looking at the test, I think testing a more complex rule might illustrate the engine's capability even better. For example, a common scenario is testing a rule that contains calling an API. Here is such scenario:

{
    "input": ["pokemon_name"],
    "output": ["pokemon"],
    "rule": "getPokemon(pokemon_name)",
    "value": "???"
},
{
    "input": ["pokemon"],
    "output": ["isGoodPokemon"],
    "rule": "['dragon', 'fairy'].includes(pokemon.type)",
    "value": "true"
}

From the above sample, some questions arose:

1. How to call an API inside the rule?
2. How to store pokemon data fetched from the API to the output?
3. How to store pokemon data (that is probably a struct that contains a lot of attributes?
4. How to check array inclusion as seen in the second rule?
5. How to handle error that we might get from calling the API?

Performance issue add cache for parsed rule

Currently caching parsed rules only cached as long as the rule has not been changed. It is better to treat each of the rule individually.
we can use help of LRU (https://github.com/hashicorp/golang-lru)

Multiple output from rules

We need to have functionality of managing multiple results from an expression.

Double execution

In current algorithm, fished will map rules to a index:
example if we have input : ["A", "B"] it will be transform into { "A": [1], "B": [1] } (assume only one rule and in index 1 in the rule arrays) at runtime if both "required parameters" are met the rule will fire. In this case because the rule is successfully verified for both of these inputs, it will be fired twice hence double execution.