make use of maps to speed up oneof and noneof

Author: huttotw

README.md

@@ -1,13 +1,15 @@
 [![CircleCI](https://circleci.com/gh/huttotw/grules/tree/master.svg?style=svg)](https://circleci.com/gh/huttotw/grules/tree/master)
 
 # Introduction
+
 This package was created with inspiration from Thomas' [go-ruler](https://github.com/hopkinsth/go-ruler) to run a simple set of rules against an entity.
 
 This version includes a couple more features including, AND and OR composites and the ability to add custom comparators.
 
 **Note**: This package only compares two types: `string` and `float64`, this plays nicely with `encoding/json`.
 
 # Example
+
 ```go
 // Create a new instance of an engine with some default comparators
 e := NewEngine()
@@ -49,54 +51,56 @@ res := e.Evaluate(props)
 ```
 
 # Comparators
-* `eq` will return true if `a == b`
-* `neq` will return true if `a != b`
-* `lt` will return true if `a < b`
-* `lte` will return true if `a <= b`
-* `gt` will return true if `a > b`
-* `gte` will return true if `a >= b`
-* `contains` will return true if `a` contains `b`
-* `oneof` will return true if `a` is one of `b`
+
+- `eq` will return true if `a == b`
+- `neq` will return true if `a != b`
+- `lt` will return true if `a < b`
+- `lte` will return true if `a <= b`
+- `gt` will return true if `a > b`
+- `gte` will return true if `a >= b`
+- `contains` will return true if `a` contains `b`
+- `oneof` will return true if `a` is one of `b`
 
 `contains` is different than `oneof` in that `contains` expects the first argument to be a slice, and `oneof` expects the second argument to be a slice.
 
 # Benchmarks
 
-|Benchmark|N|Speed|Used|Allocs|
-|---------|----------|-----|------|------|
-|BenchmarkEqual-12|1000000000|5.22 ns/op|0 B/op|0 allocs/op|
-|BenchmarkNotEqual-12|2000000000|3.77 ns/op|0 B/op|0 allocs/op|
-|BenchmarkLessThan-12|2000000000|2.20 ns/op|0 B/op|0 allocs/op|
-|BenchmarkLessThanEqual-12|2000000000|1.95 ns/op|0 B/op|0 allocs/op|
-|BenchmarkGreaterThan-12|5000000000|1.95 ns/op|0 B/op|0 allocs/op|
-|BenchmarkGreaterThanEqual-12|2000000000|1.97 ns/op|0 B/op|0 allocs/op|
-|BenchmarkContains-12|1000000000|5.66 ns/op|0 B/op|0 allocs/op|
-|BenchmarkContainsLong50000-12|30000|157679 ns/op|0 B/op|0 allocs/op|
-|BenchmarkNotContains-12|500000000|11.5 ns/op|0 B/op|0 allocs/op|
-|BenchmarkNotContainsLong50000-12|30000|157437 ns/op|0 B/op|0 allocs/op|
-|BenchmarkOneOf-12|500000000|11.0 ns/op|0 B/op|0 allocs/op|
-|BenchmarkNoneOf-12|500000000|10.7 ns/op|0 B/op|0 allocs/op|
-|BenchmarkPluckShallow-12|100000000|42.4 ns/op|16 B/op|1 allocs/op|
-|BenchmarkPluckDeep-12|30000000|174 ns/op|112 B/op|1 allocs/op|
-|BenchmarkRule_evaluate-12|100000000|51.7 ns/op|16 B/op|1 allocs/op|
-|BenchmarkComposite_evaluate-12|100000000|58.9 ns/op|16 B/op|1 allocs/op|
-|BenchmarkEngine_Evaluate-12|100000000|69.9 ns/op|16 B/op|1 allocs/op|
+| Benchmark                        | N          | Speed        | Used     | Allocs      |
+| -------------------------------- | ---------- | ------------ | -------- | ----------- |
+| BenchmarkEqual-12                | 1000000000 | 5.22 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkNotEqual-12             | 2000000000 | 3.77 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkLessThan-12             | 2000000000 | 2.20 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkLessThanEqual-12        | 2000000000 | 1.95 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkGreaterThan-12          | 5000000000 | 1.95 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkGreaterThanEqual-12     | 2000000000 | 1.97 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkContains-12             | 1000000000 | 5.66 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkContainsLong50000-12    | 30000      | 157679 ns/op | 0 B/op   | 0 allocs/op |
+| BenchmarkNotContains-12          | 500000000  | 11.5 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkNotContainsLong50000-12 | 30000      | 157437 ns/op | 0 B/op   | 0 allocs/op |
+| BenchmarkOneOf-12                | 500000000  | 0.53 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkNoneOf-12               | 500000000  | 0.53 ns/op   | 0 B/op   | 0 allocs/op |
+| BenchmarkPluckShallow-12         | 100000000  | 42.4 ns/op   | 16 B/op  | 1 allocs/op |
+| BenchmarkPluckDeep-12            | 30000000   | 174 ns/op    | 112 B/op | 1 allocs/op |
+| BenchmarkRule_evaluate-12        | 100000000  | 51.7 ns/op   | 16 B/op  | 1 allocs/op |
+| BenchmarkComposite_evaluate-12   | 100000000  | 58.9 ns/op   | 16 B/op  | 1 allocs/op |
+| BenchmarkEngine_Evaluate-12      | 100000000  | 69.9 ns/op   | 16 B/op  | 1 allocs/op |
 
 To run benchmarks:
+
 ```
 go test -run none -bench . -benchtime 3s -benchmem
 ```
 
 All benchmarks were run on:
- 
- MacOS High Sierra 2.6Ghz Intel Core i7 16 GB 2400 MHz DDR4
+
+MacOS High Sierra 2.6Ghz Intel Core i7 16 GB 2400 MHz DDR4
 
 # License
 
-Copyright &copy; 2018 Trevor Hutto
+Copyright &copy; 2019 Trevor Hutto
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with the License. You may obtain a copy of the License in the LICENSE file, or at:
 
 http://www.apache.org/licenses/LICENSE-2.0
 
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

comparators.go

@@ -225,10 +225,30 @@ func notContains(a, b interface{}) bool {
 
 // oneOf will return true if b contains a
 func oneOf(a, b interface{}) bool {
-	return contains(b, a)
+	m, ok := b.(map[interface{}]struct{})
+	if !ok {
+		return false
+	}
+
+	_, found := m[a]
+	if found {
+		return true
+	}
+
+	return false
 }
 
 // noneOf will return true if b does not contain a
 func noneOf(a, b interface{}) bool {
-	return notContains(b, a)
+	m, ok := b.(map[interface{}]struct{})
+	if !ok {
+		return false
+	}
+
+	_, found := m[a]
+	if !found {
+		return true
+	}
+
+	return false
 }

comparators_test.go

@@ -245,12 +245,12 @@ func BenchmarkOneOf(b *testing.B) {
 
 func TestOneOf(t *testing.T) {
 	cases := []testCase{
-		testCase{args: []interface{}{"a", []interface{}{"a", "b"}}, expected: true},
-		testCase{args: []interface{}{"c", []interface{}{"a", "b"}}, expected: false},
-		testCase{args: []interface{}{float64(1), []interface{}{"a", "b"}}, expected: false},
-		testCase{args: []interface{}{float64(1), []interface{}{float64(1), float64(2)}}, expected: true},
-		testCase{args: []interface{}{float64(3), []interface{}{float64(1), float64(2)}}, expected: false},
-		testCase{args: []interface{}{float64(1.01), []interface{}{float64(1.01), float64(1.02)}}, expected: true},
+		testCase{args: []interface{}{"a", map[interface{}]struct{}{"a": struct{}{}, "b": struct{}{}}}, expected: true},
+		testCase{args: []interface{}{"c", map[interface{}]struct{}{"a": struct{}{}, "b": struct{}{}}}, expected: false},
+		testCase{args: []interface{}{float64(1), map[interface{}]struct{}{"a": struct{}{}, "b": struct{}{}}}, expected: false},
+		testCase{args: []interface{}{float64(1), map[interface{}]struct{}{float64(1): struct{}{}, float64(2): struct{}{}}}, expected: true},
+		testCase{args: []interface{}{float64(3), map[interface{}]struct{}{float64(1): struct{}{}, float64(2): struct{}{}}}, expected: false},
+		testCase{args: []interface{}{float64(1.01), map[interface{}]struct{}{1.01: struct{}{}, 1.02: struct{}{}}}, expected: true},
 	}
 	for i, c := range cases {
 		res := oneOf(c.args[0], c.args[1])
@@ -268,13 +268,13 @@ func BenchmarkNoneOf(b *testing.B) {
 
 func TestNoneOf(t *testing.T) {
 	cases := []testCase{
-		testCase{args: []interface{}{"a", []interface{}{"a", "b"}}, expected: false},
-		testCase{args: []interface{}{"c", []interface{}{"a", "b"}}, expected: true},
-		testCase{args: []interface{}{float64(1), []interface{}{"a", "b"}}, expected: true},
-		testCase{args: []interface{}{float64(1), []interface{}{float64(1), float64(2)}}, expected: false},
-		testCase{args: []interface{}{float64(3), []interface{}{float64(1), float64(2)}}, expected: true},
-		testCase{args: []interface{}{float64(1.01), []interface{}{float64(1.01), float64(1.02)}}, expected: false},
-		testCase{args: []interface{}{float64(1.03), []interface{}{float64(1.01), float64(1.02)}}, expected: true},
+		testCase{args: []interface{}{"a", map[interface{}]struct{}{"a": struct{}{}, "b": struct{}{}}}, expected: false},
+		testCase{args: []interface{}{"c", map[interface{}]struct{}{"a": struct{}{}, "b": struct{}{}}}, expected: true},
+		testCase{args: []interface{}{float64(1), map[interface{}]struct{}{"a": struct{}{}, "b": struct{}{}}}, expected: true},
+		testCase{args: []interface{}{float64(1), map[interface{}]struct{}{float64(1): struct{}{}, float64(2): struct{}{}}}, expected: false},
+		testCase{args: []interface{}{float64(3), map[interface{}]struct{}{float64(1): struct{}{}, float64(2): struct{}{}}}, expected: true},
+		testCase{args: []interface{}{float64(1.01), map[interface{}]struct{}{1.01: struct{}{}, 1.02: struct{}{}}}, expected: false},
+		testCase{args: []interface{}{float64(1.03), map[interface{}]struct{}{1.01: struct{}{}, 1.02: struct{}{}}}, expected: true},
 	}
 
 	for i, c := range cases {

rule.go

@@ -37,6 +37,63 @@ type Rule struct {
 	Value      interface{} `json:"value"`
 }
 
+func (r *Rule) MarshalJSON() ([]byte, error) {
+	type unmappedRule struct {
+		Comparator string      `json:"comparator"`
+		Path       string      `json:"path"`
+		Value      interface{} `json:"value"`
+	}
+
+	switch t := r.Value.(type) {
+	case map[interface{}]struct{}:
+		var s []interface{}
+		for k := range t {
+			s = append(s, k)
+		}
+		r.Value = s
+	}
+
+	umr := unmappedRule{
+		Comparator: r.Comparator,
+		Path:       r.Path,
+		Value:      r.Value,
+	}
+
+	return json.Marshal(umr)
+}
+
+func (r *Rule) UnmarshalJSON(data []byte) error {
+	type mapRule struct {
+		Comparator string      `json:"comparator"`
+		Path       string      `json:"path"`
+		Value      interface{} `json:"value"`
+	}
+
+	var mr mapRule
+	err := json.Unmarshal(data, &mr)
+	if err != nil {
+		return err
+	}
+
+	switch t := mr.Value.(type) {
+	case []interface{}:
+		var m = make(map[interface{}]struct{})
+		for _, v := range t {
+			m[v] = struct{}{}
+		}
+
+		mr.Value = m
+	}
+
+	*r = Rule{
+		Comparator: mr.Comparator,
+		Path:       mr.Path,
+		Value:      mr.Value,
+	}
+
+	return nil
+}
+
 // Composite is a group of rules that are joined by a logical operator
 // AND or OR. If the operator is AND all of the rules must be true,
 // if the operator is OR, one of the rules must be true.

rule_test.go

@@ -1,6 +1,8 @@
 package grules
 
 import (
+	"encoding/json"
+	"reflect"
 	"testing"
 )
 
@@ -81,6 +83,42 @@ func BenchmarkRule_evaluate(b *testing.B) {
 	}
 }
 
+func TestRule_MarshalJSON(t *testing.T) {
+	t.Run("simple engine", func(t *testing.T) {
+		j := []byte(`{"composites":[{"operator":"and","rules":[{"comparator":"eq","path":"first_name","value":"Trevor"}]}]}`)
+		e, err := NewJSONEngine(j)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		b, err := json.Marshal(e)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if string(b) != string(j) {
+			t.Fatal("expected json to be same")
+		}
+	})
+
+	t.Run("list to map", func(t *testing.T) {
+		j := []byte(`{"composites":[{"operator":"and","rules":[{"comparator":"oneof","path":"first_name","value":["Trevor"]}]}]}`)
+		e, err := NewJSONEngine(j)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		b, err := json.Marshal(e)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if string(b) != string(j) {
+			t.Fatal("expected json to be same")
+		}
+	})
+}
+
 func TestComposite_evaluate(t *testing.T) {
 	comparators := map[string]Comparator{
 		"eq": equal,
@@ -220,17 +258,37 @@ func TestAddComparator(t *testing.T) {
 }
 
 func TestNewJSONEngine(t *testing.T) {
-	j := []byte(`{"composites":[{"operator":"and","rules":[{"comparator":"eq","path":"first_name","value":"Trevor"}]}]}`)
-	e, err := NewJSONEngine(j)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(e.Composites) != 1 {
-		t.Fatal("expected 1 composite")
-	}
-	if len(e.Composites[0].Rules) != 1 {
-		t.Fatal("expected 1 rule in first composite")
-	}
+	t.Run("simple engine", func(t *testing.T) {
+		j := []byte(`{"composites":[{"operator":"and","rules":[{"comparator":"eq","path":"first_name","value":"Trevor"}]}]}`)
+		e, err := NewJSONEngine(j)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(e.Composites) != 1 {
+			t.Fatal("expected 1 composite")
+		}
+		if len(e.Composites[0].Rules) != 1 {
+			t.Fatal("expected 1 rule in first composite")
+		}
+	})
+
+	t.Run("list to map", func(t *testing.T) {
+		j := []byte(`{"composites":[{"operator":"and","rules":[{"comparator":"oneof","path":"first_name","value":["Trevor"]}]}]}`)
+		e, err := NewJSONEngine(j)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(e.Composites) != 1 {
+			t.Fatal("expected 1 composite")
+		}
+		if len(e.Composites[0].Rules) != 1 {
+			t.Fatal("expected 1 rule in first composite")
+		}
+
+		if reflect.TypeOf(e.Composites[0].Rules[0].Value).Kind() != reflect.Map {
+			t.Fatal("expected list to be transformed to map")
+		}
+	})
 }
 
 func TestEngineEvaluate(t *testing.T) {