added normalform, added matchstrings

Author: Codehardt

normalform.go

@@ -0,0 +1,174 @@
+package evalostic
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+type matchstr struct {
+	not bool
+	ci  bool
+	str string
+}
+
+type matchpath []matchstr
+
+func (m matchpath) String() string {
+	allStrings := make([]string, len(m))
+	for i, str := range m {
+		allStrings[i] = str.String()
+	}
+	return strings.Join(allStrings, ", ")
+}
+
+func (m matchstr) String() string {
+	var suffix string
+	if m.ci {
+		suffix = "i"
+	}
+	var prefix string
+	if m.not {
+		prefix = "NOT "
+	}
+	return fmt.Sprintf("%s%q%s", prefix, m.str, suffix)
+}
+
+func MatchStrings(n node) []matchpath {
+	res := matchStrings(n)
+	for _, path := range res {
+		sort.Slice(path, func(i, j int) bool {
+			s1, s2 := path[i], path[j]
+			if s1.not && !s2.not {
+				return false
+			}
+			if !s1.not && s2.not {
+				return true
+			}
+			return strings.Compare(s1.str, s2.str) < 0
+		})
+	}
+	return res
+}
+
+func matchStrings(n node) []matchpath {
+	switch v := n.(type) {
+	case nodeAND:
+		return []matchpath{append(matchStrings(v.node1)[0], matchStrings(v.node2)[0]...)}
+	case nodeOR:
+		return append(matchStrings(v.node1), matchStrings(v.node2)...)
+	case nodeNOT:
+		val := v.node.(nodeVAL)
+		return []matchpath{
+			{matchstr{
+				not: true,
+				ci:  val.caseInsensitive,
+				str: val.nodeValue,
+			}},
+		}
+	case nodeVAL:
+		return []matchpath{
+			{matchstr{
+				not: false,
+				ci:  v.caseInsensitive,
+				str: v.nodeValue,
+			}},
+		}
+	default:
+		panic("unknown node type")
+	}
+}
+
+func (n nodeAND) NormalForm() node {
+	n.node1 = n.node1.NormalForm()
+	if or, ok := n.node1.(nodeOR); ok {
+		return (nodeOR{
+			twoSubNodes{
+				node1: nodeAND{
+					twoSubNodes{
+						node1: or.node1,
+						node2: n.node2,
+					},
+				},
+				node2: nodeAND{
+					twoSubNodes{
+						node1: or.node2,
+						node2: n.node2,
+					},
+				},
+			},
+		}).NormalForm()
+	}
+	n.node2 = n.node2.NormalForm()
+	if or, ok := n.node2.(nodeOR); ok {
+		return (nodeOR{
+			twoSubNodes{
+				node1: nodeAND{
+					twoSubNodes{
+						node1: n.node1,
+						node2: or.node1,
+					},
+				},
+				node2: nodeAND{
+					twoSubNodes{
+						node1: n.node1,
+						node2: or.node2,
+					},
+				},
+			},
+		}).NormalForm()
+	}
+	return n
+}
+
+func (n nodeOR) NormalForm() node {
+	n.node1 = n.node1.NormalForm()
+	n.node2 = n.node2.NormalForm()
+	return n
+}
+
+func (n nodeNOT) NormalForm() node {
+	n.node = n.node.NormalForm()
+	switch v := n.node.(type) {
+	case nodeAND:
+		return (nodeOR{
+			twoSubNodes{
+				node1: nodeNOT{
+					oneSubNode{
+						node: v.node1,
+					},
+				},
+				node2: nodeNOT{
+					oneSubNode{
+						node: v.node2,
+					},
+				},
+			},
+		}).NormalForm()
+	case nodeOR:
+		return (nodeAND{
+			twoSubNodes{
+				node1: nodeNOT{
+					oneSubNode{
+						node: v.node1,
+					},
+				},
+				node2: nodeNOT{
+					oneSubNode{
+						node: v.node2,
+					},
+				},
+			},
+		}).NormalForm()
+	case nodeVAL:
+		return n
+	case nodeNOT:
+		return v.node
+	default:
+		panic("unknown node type")
+	}
+}
+
+func (n nodeVAL) NormalForm() node {
+	return n
+}

normalform_test.go

@@ -0,0 +1,50 @@
+package evalostic
+
+import "fmt"
+
+func ExampleNormalForm() {
+	nf := func(cond string) {
+		n, err := parseCondition(cond)
+		if err != nil {
+			panic(err)
+		}
+		fmt.Printf("----- %s -----\n", cond)
+		fmt.Println("before:", n.Condition())
+		n = n.NormalForm()
+		fmt.Println("after:", n.Condition())
+	}
+	nf(`"a"`)
+	nf(`NOT "a"`)
+	nf(`"a" AND "b"`)
+	nf(`"a" OR "b"`)
+	nf(`"a" AND ("b" OR "c")`)
+	nf(`"a" OR ("b" AND "c")`)
+	nf(`"a" AND NOT ("b" OR "c")`)
+	nf(`"a" OR NOT ("b" AND "c")`)
+	nf(`"a" AND ("b" OR NOT "c")`)
+	nf(`"a" OR ("b" AND NOT "c")`)
+	nf(`"a" AND NOT ("b" OR NOT "c")`)
+	nf(`"a" OR NOT ("b" AND NOT "c")`)
+	nf(`"a" OR ("b" OR ("c" OR "d"))`)
+	nf(`("a" OR "b") OR ("c" OR "d")`)
+	// Output:
+	//
+}
+
+func ExampleMatchStrings() {
+	ms := func(cond string) {
+		n, err := parseCondition(cond)
+		if err != nil {
+			panic(err)
+		}
+		fmt.Printf("----- %s -----\n", cond)
+		n = n.NormalForm()
+		matchStrings := MatchStrings(n)
+		for _, matchPath := range matchStrings {
+			fmt.Println(matchPath.String())
+		}
+	}
+	ms(`("a" AND NOT "b") OR (NOT "c" AND "d")`)
+	// Output:
+	//
+}

parser.go

@@ -3,13 +3,16 @@ package evalostic
 import (
 	"errors"
 	"fmt"
+	"strconv"
 	"strings"
 )
 
 type node interface {
 	String() string
+	Condition() string
 	Value() string
 	Children() (node, node)
+	NormalForm() node
 }
 
 type (
@@ -69,11 +72,11 @@ func parse(tokens []token) (node, error) {
 		)
 		for {
 			if offset >= len(tokens)-1 {
-				return nil, errors.New("missing matching closing parentheses")
+				return nil, errors.New("missing matching closing parentheses 1")
 			}
 			rPos = findToken(tokens[offset:], tokenTypeRPAR)
 			if rPos < 0 {
-				return nil, errors.New("missing matching closing parentheses")
+				return nil, errors.New("missing matching closing parentheses 2")
 			}
 			rPos += offset
 			if lPos+1 == rPos {
@@ -158,3 +161,22 @@ func parse(tokens []token) (node, error) {
 	}
 	return startNode, nil
 }
+
+func (n nodeAND) Condition() string {
+	return fmt.Sprintf("(%s AND %s)", n.node1.Condition(), n.node2.Condition())
+}
+
+func (n nodeOR) Condition() string {
+	return fmt.Sprintf("(%s OR %s)", n.node1.Condition(), n.node2.Condition())
+}
+
+func (n nodeVAL) Condition() string {
+	if n.caseInsensitive {
+		return strconv.Quote(n.nodeValue) + "i"
+	}
+	return strconv.Quote(n.nodeValue)
+}
+
+func (n nodeNOT) Condition() string {
+	return fmt.Sprintf("NOT %s", n.node.Condition())
+}