fished

README

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

Documentation

Index

• Variables
• type Engine
  • func New() *Engine
  • func NewWithCustomWorkerSize(worker int) *Engine
  • func (e *Engine) NewRuntime(facts map[string]interface{}) *Runtime
  • func (e *Engine) Run(target string, worker int) (interface{}, []error)
  • func (e *Engine) RunDefault() (interface{}, []error)
  • func (e *Engine) RunWithCustomTarget(target string) (interface{}, []error)
  • func (e *Engine) Set(facts map[string]interface{}, rules []Rule, ...) error
  • func (e *Engine) SetFacts(facts map[string]interface{}) error
  • func (e *Engine) SetRuleFunctions(ruleFunctions map[string]RuleFunction) error
  • func (e *Engine) SetRules(rules []Rule) error
• type EvalResult
• type Job
• type Rule
• type RuleFunction
• type Runtime
  • func (r *Runtime) Evaluate(job *Job, result chan<- *EvalResult)
  • func (r *Runtime) Reset() error

Variables

var (
	//DefaultTarget is the default target facts
	DefaultTarget = "result_end"

	// DefaultWorker is the default worker for Engine
	DefaultWorker = 0

	// DefaultRuleLength ...
	DefaultRuleLength = 100
)

Types

type Engine

type Engine struct {
	InitialFacts  map[string]interface{}
	Rules         []Rule
	RuleFunctions map[string]govaluate.ExpressionFunction
	RuleCache     *cache.Cache
	RunLock       sync.RWMutex
	RuntimePool   *pool.ReferenceCountedPool
}

Engine core of the machine

func New

func New() *Engine

New will create new engine

func NewWithCustomWorkerSize

func NewWithCustomWorkerSize(worker int) *Engine

NewWithCustomWorkerSize ...

func (*Engine) NewRuntime

func (e *Engine) NewRuntime(facts map[string]interface{}) *Runtime

NewRuntime ...

func (*Engine) Run

func (e *Engine) Run(target string, worker int) (interface{}, []error)

Run will execute rule and facts to get the result DEPRICATION NOTICE : worker param is depricated since it has been moved to engine struct

func (*Engine) RunDefault

func (e *Engine) RunDefault() (interface{}, []error)

RunDefault will execute run with default parameneter

func (*Engine) RunWithCustomTarget

func (e *Engine) RunWithCustomTarget(target string) (interface{}, []error)

RunWithCustomTarget will execute run using customizable end target

func (*Engine) Set

func (e *Engine) Set(facts map[string]interface{}, rules []Rule, ruleFunction map[string]RuleFunction) error

Set all of engine attibutes in one single function

func (*Engine) SetFacts

func (e *Engine) SetFacts(facts map[string]interface{}) error

SetFacts will set current engine with initial facts (replace the old one)

func (*Engine) SetRuleFunctions

func (e *Engine) SetRuleFunctions(ruleFunctions map[string]RuleFunction) error

SetRuleFunctions will set current engine with Expression Functions

func (*Engine) SetRules

func (e *Engine) SetRules(rules []Rule) error

SetRules will set current engine with rules

type EvalResult

type EvalResult struct {
	Key   string
	Value interface{}
	Error error
}

EvalResult is evaluation Result

type Job

type Job struct {
	Output           string
	ParsedExpression *govaluate.EvaluableExpression
}

Job struct

type Rule

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

Rule is struct for rule in fished

type RuleFunction

type RuleFunction func(...interface{}) (interface{}, error)

RuleFunction if type defined for rule function

type Runtime

type Runtime struct {
	pool.ReferenceCounter
	Facts      map[string]interface{}
	JobCh      chan *Job
	ResultCh   chan *EvalResult
	UsedRule   map[int]struct{}
	FactsMutex sync.RWMutex
}

Runtime is an struct for each time Engine.Run() is called

func (*Runtime) Evaluate

func (r *Runtime) Evaluate(job *Job, result chan<- *EvalResult)

Evaluate will evaluate each job in runtime

func (*Runtime) Reset

func (r *Runtime) Reset() error

Reset Current Runtime