initial commit

Author: ahuangg

README.md

@@ -0,0 +1,82 @@
+# JSON Rules
+
+The JSON Rules serves as an abstraction layer over the [Golang Rules Engine](https://github.com/nikunjy/rules/blob/master/README.md).
+
+This packages allows you to represent rules in JSON format instead of using the original ANTLR query syntax from the nikunjy/rules implementation.
+
+## Example Queries
+
+You can find example queries in the [examples/](test/examples/) directory.
+
+## Operations
+
+The following operations are supported, matching those available in the [Golang Rules Engine](https://github.com/nikunjy/rules):
+
+| expression | meaning                                         |
+| ---------- | ----------------------------------------------- |
+| eq         | equals to                                       |
+| ==         | equals to                                       |
+| ne         | not equal to                                    |
+| !=         | not equal to                                    |
+| lt         | less than                                       |
+| <          | less than                                       |
+| gt         | greater than                                    |
+| >          | greater than                                    |
+| le         | less than or equal to                           |
+| <=         | less than or equal to                           |
+| ge         | greater than or equal to                        |
+| >=         | greater than or equal to                        |
+| co         | contains                                        |
+| sw         | starts with                                     |
+| ew         | ends with                                       |
+| in         | in a list                                       |
+| pr         | present, will be true if you have a key as true |
+| not        | not of a logical expression                     |
+
+## JSON Rule Example
+
+To create JSON rules, follow these steps:
+
+1. The `and` and `or`operation accepts a list of conditions. The and operation evaluates to true only if all conditions in the list are true, while the or operation evaluates to true if at least one condition is true. They are formatted as follows:
+
+```json
+{
+    "and": [
+		{ "==": [{ "var": "y" }, 4] }, 
+		{ ">": [{ "var": "x" }, 1] }
+	]
+}
+```
+
+```json
+{
+    "or": [
+        { "==": [{ "var": "y" }, 4] },
+        { ">": [{ "var": "x" }, 1] },
+        { ">": [{ "var": "x" }, 1] }
+    ]
+}
+```
+
+2. Other operations, such as `eq`, `ne`, `lt`, `gt`, `le`, `ge`, `in`, and others, are formatted to take exactly two operands. Here’s an example of the `eq` operation:
+
+```json
+{
+    "eq": [{ "var": "x" }, 1]
+}
+```
+
+## How to use
+This example demonstrates how to initialize the parser with a JSON rule and evaluate it against a set of data. Adjust the paths and data as necessary for your specific use case.
+
+```Go
+    p := parser.NewParser(filepath.Join("examples", "example.json"))
+	err := p.ParseRule()
+    if err != nil {
+        t.Errorf("%v", err)
+    }
+	testData := map[string]interface{}{
+       "x" : 1,
+    }
+	result := p.Evaluate(testData)
+```

go.mod

@@ -0,0 +1,17 @@
+module github.com/ahuangg/json_rules
+
+go 1.23.3
+
+require (
+	github.com/nikunjy/rules v1.5.0
+	github.com/stretchr/testify v1.10.0
+)
+
+require (
+	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
+	github.com/blang/semver v3.5.1+incompatible // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,18 @@
+github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8TVTI=
+github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g=
+github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
+github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/nikunjy/rules v1.5.0 h1:KJDSLOsFhwt7kcXUyZqwkgrQg5YoUwj+TVu6ItCQShw=
+github.com/nikunjy/rules v1.5.0/go.mod h1:TlZtZdBChrkqi8Lr2AXocme8Z7EsbxtFdDoKeI6neBQ=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

parser/parser.go

@@ -0,0 +1,68 @@
+package parser
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/nikunjy/rules/parser"
+)
+
+type Parser struct {
+	filePath string
+	rule     string
+}
+
+func NewParser(filePath string) *Parser {
+	return &Parser{
+		filePath: filePath,
+	}
+}
+
+func (p *Parser) ParseRule() error {
+	fileData, err := os.ReadFile(p.filePath)
+	if err != nil {
+		return err
+	}
+
+	var ruleData map[string]interface{}
+	if err := json.Unmarshal(fileData, &ruleData); err != nil {
+		return err
+	}
+
+	p.rule = p.formatRule(ruleData)
+
+	return nil
+}
+
+func (p *Parser) formatRule(node map[string]interface{}) string {
+    for _, key := range []string{"and", "or"} {
+        if rulesList, ok := node[key].([]interface{}); ok {
+            rules := make([]string, len(rulesList))
+            for i, r := range rulesList {
+                rules[i] = p.formatRule(r.(map[string]interface{}))
+            }
+            return "(" + strings.Join(rules, " "+key+" ") + ")"
+        }
+    }
+
+    for op, value := range node {
+        values := value.([]interface{})
+        left := values[0]
+        if m, ok := left.(map[string]interface{}); ok {
+            left = m["var"]
+        }
+        return "(" + fmt.Sprintf("%v %s %v", left, op, values[1]) + ")"
+    }
+
+    return ""
+}
+
+func (p *Parser) Evaluate(items map[string]interface{}) bool {
+	return parser.Evaluate(p.rule, items)
+}
+
+func (p *Parser) GetRule() string {
+    return p.rule
+}

test/examples/eq2_test.json

@@ -0,0 +1,3 @@
+{
+    "==": [{ "var": "x" }, 2]
+}

test/examples/eq_and_gt_test.json

@@ -0,0 +1,6 @@
+{
+    "and": [
+        {"==": [{"var": "y"}, 4]},
+        {">": [{"var": "x"}, 1]}
+    ]
+} 

test/examples/eq_and_lte_test.json

@@ -0,0 +1,6 @@
+{
+    "and": [
+        {"==": [{"var": "x.a"}, 1]},
+        {"<=": [{"var": "x.b.c"}, 2]}
+    ]
+} 

test/examples/eq_string_test.json

@@ -0,0 +1,6 @@
+{
+    "and": [
+        {"==": [{"var": "y"}, 4]},
+        {"eq": [{"var": "x"}, "1.2.3"]}
+    ]
+} 

test/examples/eq_test.json

@@ -0,0 +1,3 @@
+{
+    "eq": [{ "var": "x" }, 1]
+}

test/examples/gt2_test.json

@@ -0,0 +1,3 @@
+{
+    ">": [{ "var": "x" }, 2]
+}

test/examples/gt_test.json

@@ -0,0 +1,3 @@
+{
+    ">": [{ "var": "x" }, 0]
+}

test/examples/in_test.json

@@ -0,0 +1,6 @@
+{
+    "and": [
+        {"==": [{"var": "y"}, 4]},
+        {"in": [{"var": "x"}, [1, 2, 3]]}
+    ]
+} 

test/examples/lt2_test.json

@@ -0,0 +1,3 @@
+{
+    "<": [{"var": "x"}, 1]
+} 

test/examples/lt_test.json

@@ -0,0 +1,3 @@
+{
+    "<": [{ "var": "x" }, 2]
+}