README
¶
json-logic-go
This parser accepts JsonLogic rules and executes them in Go.
The JsonLogic format is designed to allow you to share rules (logic) between front-end and back-end code (regardless of language difference), even to store logic along with a record in a database. JsonLogic is documented extensively at JsonLogic.com, including examples of every supported operation and a place to try out rules in your browser.
The same format can be executed in the following libraries:
- JavaScript json-logic-js
- PHP json-logic-php
- Python json-logic-py
- Ruby json-logic-ruby
- Go json-logic-go
Examples
A note about types
This is a GO interpreter of a format designed to be transmitted and stored as JSON. So it makes sense to conceptualize the rules in JSON.
Expressed in JSON, a JsonLogic rule is always one key, with an array of values.
rule := `{"==":["apples", "apples"]}`
result, err := jsonlogic.Run(rule)
if err != nil {
fmt.Println(err)
}
fmt.Println(result)
// true
Simple
rule := `{"==":[1, 1]}`
result, err := jsonlogic.Run(rule)
if err != nil {
fmt.Println(err)
}
fmt.Println(result)
// true
This is a simple test, equivalent to 1 == 1. A few things about the format:
- The operator is always in the "key" position. There is only one key per JsonLogic rule.
- The values are typically an array.
- Each value can be a string, number, boolean, array, or null
Compound
Here we're beginning to nest rules.
rule := `{"and": [
{ ">": [3,1] },
{ "<": [1,3] }
] }`
result, err := jsonlogic.Run(rule)
if err != nil {
fmt.Println(err)
}
fmt.Println(result)
// true
Data-Driven
Obviously these rules aren't very interesting if they can only take static literal data. Typically jsonlogic.Apply will be called with a rule object and a data object however you can also use jsonlogic.Run to run a rule object without a data object. You can use the var operator to get attributes of the data object:
rule := `{ "var": ["a"] }`
data := `{ "a": 1, "b": 2 }`
result, err := jsonlogic.Apply(rule, data)
if err != nil {
fmt.Println(err)
}
fmt.Println(result)
// 1
If you like, we support syntactic sugar on unary operators to skip the array around values:
You can also use the var operator to access an array by numeric index:
rule := `{ "var": 1 }`
data := `[ "apple", "banana", "carrot" ]`
result, err := jsonlogic.Apply(rule, data)
if err != nil {
fmt.Println(err)
}
fmt.Println(result)
// "banana"
Here's a complex rule that mixes literals and data. The pie isn't ready to eat unless it's cooler than 110 degrees, and filled with apples.
rule := `{ "and": [
{ "<": [ { "var": "temp" }, 110 ] },
{ "==": [ { "var": "pie.filling" }, "apple" ] }
] }`
data := `{ "temp": 100, "pie": { "filling": "apple" } }`
result, err := jsonlogic.Apply(rule, data)
if err != nil {
fmt.Println(err)
}
fmt.Println(result)
// true
Installation
go get github.com/GeorgeD19/json-logic-go
If that doesn't suit you, and you want to manage updates yourself, the entire library is self-contained in jsonlogic.go and you can download it straight into your project as you see fit.
curl -O https://raw.githubusercontent.com/GeorgeD19/json-logic-go/master/jsonlogic.go
Documentation
¶
Index ¶
- Variables
- func AddOperator(key string, cb func(rule string, data string) (result interface{}))
- func And(values []interface{}) bool
- func Apply(rule string, data string) (res interface{}, errs error)
- func Cat(values []interface{}) string
- func Divide(a float64, b float64) interface{}
- func GetType(a interface{}) int
- func GetValues(rule string, data string) (results []interface{})
- func HardEqual(a ...interface{}) bool
- func If(conditions []interface{}) interface{}
- func In(a []interface{}) bool
- func IsNumeric(s interface{}) bool
- func Less(a float64, b float64) bool
- func LessBetween(a float64, b float64, c float64) bool
- func LessEqual(a float64, b float64) bool
- func LessEqualBetween(a float64, b float64, c float64) bool
- func Log(a string) interface{}
- func Max(values []interface{}) (max float64)
- func Merge(a []interface{}) interface{}
- func Min(values []interface{}) (min float64)
- func Minus(a []interface{}) interface{}
- func Missing(a []interface{}, data string) interface{}
- func More(a float64, b float64) bool
- func MoreEqual(a string, b string) bool
- func Multiply(a []interface{}) interface{}
- func NotHardEqual(a ...interface{}) bool
- func NotSoftEqual(a string, b string) bool
- func NotTruthy(a interface{}) bool
- func Or(values []interface{}) bool
- func ParseOperator(rule string, data string) (result interface{}, err error)
- func Percentage(a int, b int) float64
- func Plus(a []interface{}) interface{}
- func Run(rule string) (res interface{}, errs error)
- func RunOperator(key string, rule string, data string) (result interface{})
- func SoftEqual(a string, b string) bool
- func Substr(a string, position int, length int) string
- func TranslateType(data []byte, dataType jsonparser.ValueType) interface{}
- func Truthy(a interface{}) bool
- func Var(rules interface{}, fallback interface{}, data string) (value interface{})
Constants ¶
This section is empty.
Variables ¶
var (
ErrInvalidOperation = "invalid operation: %s"
)
Errors
var Operators = make(map[string]func(rule string, data string) (result interface{}))
Operators holds any operators
Functions ¶
func AddOperator ¶
AddOperator allows for custom operators to be used
func And ¶
func And(values []interface{}) bool
And implements the 'and' conditional requiring all bubbled up bools to be true.
func Cat ¶
func Cat(values []interface{}) string
Cat implements the 'cat' conditional returning all the values merged together.
func GetType ¶
func GetType(a interface{}) int
GetType returns an int to map against type so we can see if we are dealing with a specific type of data or an object operation.
func HardEqual ¶
func HardEqual(a ...interface{}) bool
HardEqual Implements the '===' operator, which does type JS-style coertion.
func If ¶
func If(conditions []interface{}) interface{}
If implements the 'if' conditional where if the first value is true, the second value is returned, otherwise the third. func If(conditional interface{}, success interface{}, fail interface{}) interface{} {
func LessBetween ¶
Less implements the '<' operator however checks against 3 values to test that one value is between but not equal to two others.
func LessEqualBetween ¶
Less implements the '<' operator however checks against 3 values to test that one value is between two others.
func Log ¶
func Log(a string) interface{}
Log implements the 'log' operator, which prints a log inside termianl.
func Max ¶
func Max(values []interface{}) (max float64)
Max implements the 'Max' conditional returning the Maximum value from an array of values.
func Min ¶
func Min(values []interface{}) (min float64)
Min implements the 'min' conditional returning the minimum value from an array of values.
func Minus ¶
func Minus(a []interface{}) interface{}
Minus implements the '-' operator, which does type JS-style coertion.
func Multiply ¶
func Multiply(a []interface{}) interface{}
Multiply implements the '-' operator, which does type JS-style coertion.
func NotHardEqual ¶
func NotHardEqual(a ...interface{}) bool
NotHardEqual implements the '!==' operator, which does type JS-style coertion.
func NotSoftEqual ¶
NotSoftEqual implements the '!=' operator, which does type JS-style coertion.
func NotTruthy ¶
func NotTruthy(a interface{}) bool
NotTruthy implements the '!' operator with JS-style type coertion.
func Or ¶
func Or(values []interface{}) bool
Or implements the 'or' conditional requiring at least one of the bubbled up bools to be true.
func ParseOperator ¶
ParseOperator takes in the json rule and data and attempts to parse
func Percentage ¶
Percentage implements the '%' operator, which does type JS-style coertion. Returns float64.
func Plus ¶
func Plus(a []interface{}) interface{}
Plus implements the '+' operator, which does type JS-style coertion.
func RunOperator ¶
RunOperator determines what function to run against the passed rule and data
func TranslateType ¶
func TranslateType(data []byte, dataType jsonparser.ValueType) interface{}
TranslateType Takes the returned dataType from jsonparser along with it's returned []byte data and returns the casted value.
Types ¶
This section is empty.
Source Files