Clean up finder (#11)

* removed PetarDambovaliev machine and added a fork of cludflare that returns position

* removed unused deps

* fixed testes and readme

* fixed some comments

Author: pedroegsilva

README.md

@@ -35,7 +35,7 @@ https://github.com/anknown/ahocorasick and
 https://github.com/petar-dambovaliev/aho-corasick and a regexp implementation for the `RegexEngine`. 
 But any other library can be used as long as it "implements" the `SubstringEngine` or `RegexEngine` interface.
 ```go
-    subEng := &finder.PetarDambovalievEngine{}
+    subEng := &finder.CloudflareForkEngine{}
     rgxEng := &finder.RegexpEngine{}
     caseSensitive := true
     findthem := finder.NewFinder(subEng, rgxEng, caseSensitive)
@@ -73,7 +73,7 @@ And finally you can check which expressions match on each text.
 		}
 		fmt.Printf("----------Text %d case sensitive-----------\n", i)
 		for _, expRes := range resp {
-			fmt.Printf("exp: [%s]%s | %v\n", expRes.Tag, expRes.ExpresionStr, expRes.Evaluation)
+			fmt.Printf("exp %d: [%s]%s\n", expRes.ExpresionIndex, expRes.Tag, expRes.ExpresionStr)
 		}
 	}
 ```

benchmarks/BUILD.bazel

@@ -9,6 +9,6 @@ go_test(
         "//finder",
         "@com_github_anknown_ahocorasick//:ahocorasick",
         "@com_github_cloudflare_ahocorasick//:ahocorasick",
-        "@com_github_petar_dambovaliev_aho_corasick//:aho-corasick",
+        "@com_github_pedroegsilva_ahocorasick//ahocorasick",
     ],
 )

benchmarks/benchmark_test.go

@@ -14,9 +14,9 @@ import (
 
 	akahocorasick "github.com/anknown/ahocorasick"
 	cfahocorasick "github.com/cloudflare/ahocorasick"
+	forkahocorasick "github.com/pedroegsilva/ahocorasick/ahocorasick"
 	"github.com/pedroegsilva/gofindthem/dsl"
 	"github.com/pedroegsilva/gofindthem/finder"
-	pdahocorasick "github.com/petar-dambovaliev/aho-corasick"
 )
 
 func init() {
@@ -113,8 +113,8 @@ func BenchmarkAhocorasickAnknownBuild100(b *testing.B) {
 	BMAnknownBuild(exp100, b)
 }
 
-func BenchmarkAhocorasickPetarDambovalievBuild100(b *testing.B) {
-	BMPetarDambovalievBuild(exp100, b)
+func BenchmarkAhocorasickCloudflareForkBuild100(b *testing.B) {
+	BMCloudflareForkBuild(exp100, b)
 }
 
 func BenchmarkAhocorasickCloudFlareSearch100(b *testing.B) {
@@ -133,12 +133,12 @@ func BenchmarkDslWithAnknown100(b *testing.B) {
 	BMDslSearch([]string{exp100}, &finder.AnknownEngine{}, b)
 }
 
-func BenchmarkAhocorasickPetarDambovalievSearch100(b *testing.B) {
-	BMPetarDambovalievSearch([]string{exp100}, b)
+func BenchmarkAhocorasickCloudflareForkSearch100(b *testing.B) {
+	BMCloudflareForkSearch([]string{exp100}, b)
 }
 
-func BenchmarkDslWithPetarDambovaliev100(b *testing.B) {
-	BMDslSearch([]string{exp100}, &finder.PetarDambovalievEngine{}, b)
+func BenchmarkDslWithCloudflareFork100(b *testing.B) {
+	BMDslSearch([]string{exp100}, &finder.CloudflareForkEngine{}, b)
 }
 
 // 10000 terms
@@ -171,8 +171,8 @@ func BenchmarkAhocorasickAnknownBuild10000(b *testing.B) {
 	BMAnknownBuild(exp10000, b)
 }
 
-func BenchmarkAhocorasickPetarDambovalievBuild10000(b *testing.B) {
-	BMPetarDambovalievBuild(exp10000, b)
+func BenchmarkAhocorasickCloudflareForkBuild10000(b *testing.B) {
+	BMCloudflareForkBuild(exp10000, b)
 }
 
 func BenchmarkAhocorasickCloudFlareSearch10000(b *testing.B) {
@@ -191,12 +191,12 @@ func BenchmarkDslWithAnknown10000(b *testing.B) {
 	BMDslSearch([]string{exp10000}, &finder.AnknownEngine{}, b)
 }
 
-func BenchmarkAhocorasickPetarDambovalievSearch10000(b *testing.B) {
-	BMPetarDambovalievSearch([]string{exp10000}, b)
+func BenchmarkAhocorasickCloudflareForkSearch10000(b *testing.B) {
+	BMCloudflareForkSearch([]string{exp10000}, b)
 }
 
-func BenchmarkDslWithPetarDambovaliev10000(b *testing.B) {
-	BMDslSearch([]string{exp10000}, &finder.PetarDambovalievEngine{}, b)
+func BenchmarkDslWithCloudflareFork10000(b *testing.B) {
+	BMDslSearch([]string{exp10000}, &finder.CloudflareForkEngine{}, b)
 }
 
 // dsl specific
@@ -220,12 +220,12 @@ func BenchmarkDslWithAnknown10Exps(b *testing.B) {
 	BMDslSearch(exps10, &finder.AnknownEngine{}, b)
 }
 
-func BenchmarkOnlyPetarDambovaliev10Exps(b *testing.B) {
-	BMPetarDambovalievSearch(exps10, b)
+func BenchmarkOnlyCloudflareFork10Exps(b *testing.B) {
+	BMCloudflareForkSearch(exps10, b)
 }
 
-func BenchmarkDslWithPetarDambovaliev10Exps(b *testing.B) {
-	BMDslSearch(exps10, &finder.PetarDambovalievEngine{}, b)
+func BenchmarkDslWithCloudflareFork10Exps(b *testing.B) {
+	BMDslSearch(exps10, &finder.CloudflareForkEngine{}, b)
 }
 
 func BenchmarkDslWithEmptyEngine100Exps(b *testing.B) {
@@ -248,12 +248,12 @@ func BenchmarkDslWithAnknown100Exps(b *testing.B) {
 	BMDslSearch(exps100, &finder.AnknownEngine{}, b)
 }
 
-func BenchmarkOnlyPetarDambovaliev100Exps(b *testing.B) {
-	BMPetarDambovalievSearch(exps100, b)
+func BenchmarkOnlyCloudflareFork100Exps(b *testing.B) {
+	BMCloudflareForkSearch(exps100, b)
 }
 
-func BenchmarkDslWithPetarDambovaliev100Exps(b *testing.B) {
-	BMDslSearch(exps100, &finder.PetarDambovalievEngine{}, b)
+func BenchmarkDslWithCloudflareFork100Exps(b *testing.B) {
+	BMDslSearch(exps100, &finder.CloudflareForkEngine{}, b)
 }
 
 func BenchmarkDslWithEmptyEngine1000Exps(b *testing.B) {
@@ -276,33 +276,33 @@ func BenchmarkDslWithAnknown1000Exps(b *testing.B) {
 	BMDslSearch(exps1000, &finder.AnknownEngine{}, b)
 }
 
-func BenchmarkOnlyPetarDambovaliev1000Exps(b *testing.B) {
-	BMPetarDambovalievSearch(exps1000, b)
+func BenchmarkOnlyCloudflareFork1000Exps(b *testing.B) {
+	BMCloudflareForkSearch(exps1000, b)
 }
 
-func BenchmarkDslWithPetarDambovaliev1000Exps(b *testing.B) {
-	BMDslSearch(exps1000, &finder.PetarDambovalievEngine{}, b)
+func BenchmarkDslWithCloudflareFork1000Exps(b *testing.B) {
+	BMDslSearch(exps1000, &finder.CloudflareForkEngine{}, b)
 }
 
 func BenchmarkUseCasesDsl(b *testing.B) {
 	expressions := []string{
 		`"foo" and "bar"`,
 	}
-	BMDslSearch(expressions, &finder.PetarDambovalievEngine{}, b)
+	BMDslSearch(expressions, &finder.CloudflareForkEngine{}, b)
 }
 
 func BenchmarkUseCasesDslWithRegex(b *testing.B) {
 	expressions := []string{
 		`r"foo.*bar" and r"bar.*foo"`,
 	}
-	BMDslSearch(expressions, &finder.PetarDambovalievEngine{}, b)
+	BMDslSearch(expressions, &finder.CloudflareForkEngine{}, b)
 }
 
 func BenchmarkUseCasesDslWithInord(b *testing.B) {
 	expressions := []string{
 		`INORD("foo" and "bar") and INORD("bar" and "foo")`,
 	}
-	BMDslSearch(expressions, &finder.PetarDambovalievEngine{}, b)
+	BMDslSearch(expressions, &finder.CloudflareForkEngine{}, b)
 }
 
 func BenchmarkUseCasesRegexOnly(b *testing.B) {
@@ -367,23 +367,16 @@ func BMAnknownBuild(exp string, b *testing.B) {
 	}
 }
 
-func BMPetarDambovalievBuild(exp string, b *testing.B) {
-	p := dsl.NewParser(strings.NewReader(exp100), true)
+func BMCloudflareForkBuild(exp string, b *testing.B) {
+	p := dsl.NewParser(strings.NewReader(exp), true)
 	p.Parse()
-	dict := []string{}
-
+	dict := [][]byte{}
 	for key := range p.GetKeywords() {
-		dict = append(dict, key)
+		dict = append(dict, []byte(key))
 	}
 
 	for i := 0; i < b.N; i++ {
-		builder := pdahocorasick.NewAhoCorasickBuilder(pdahocorasick.Opts{
-			AsciiCaseInsensitive: true,
-			MatchOnlyWholeWords:  false,
-			MatchKind:            pdahocorasick.LeftMostLongestMatch,
-			DFA:                  true,
-		})
-		builder.Build(dict)
+		forkahocorasick.NewMatcher(dict)
 	}
 }
 
@@ -426,27 +419,22 @@ func BMAnknownSearch(exps []string, b *testing.B) {
 	}
 }
 
-func BMPetarDambovalievSearch(exps []string, b *testing.B) {
+func BMCloudflareForkSearch(exps []string, b *testing.B) {
 	findthem := finder.NewFinder(&finder.EmptyEngine{}, &finder.RegexpEngine{}, true)
 	for _, exp := range exps {
 		findthem.AddExpression(exp)
 	}
 
-	dict := []string{}
-
+	dict := [][]byte{}
 	for key := range findthem.GetKeywords() {
-		dict = append(dict, key)
+		dict = append(dict, []byte(key))
 	}
 
-	builder := pdahocorasick.NewAhoCorasickBuilder(pdahocorasick.Opts{
-		AsciiCaseInsensitive: true,
-		MatchOnlyWholeWords:  false,
-		MatchKind:            pdahocorasick.LeftMostLongestMatch,
-		DFA:                  true,
-	})
-	bld := builder.Build(dict)
+	m := forkahocorasick.NewMatcher(dict)
+
+	content := []byte(randText100000)
 	for i := 0; i < b.N; i++ {
-		bld.FindAll(randText100000)
+		m.MatchAll(content)
 	}
 }
 

deps.bzl

@@ -26,10 +26,10 @@ def go_dependencies():
         version = "v1.1.0",
     )
     go_repository(
-        name = "com_github_petar_dambovaliev_aho_corasick",
-        importpath = "github.com/petar-dambovaliev/aho-corasick",
-        sum = "h1:WuXe30Ig5zUIYEHyzsLMBFPP5l0yRQ5IiZScODHwy8g=",
-        version = "v0.0.0-20210512121028-af76a9ff7276",
+        name = "com_github_pedroegsilva_ahocorasick",
+        importpath = "github.com/pedroegsilva/ahocorasick",
+        sum = "h1:N5egH9vhDB1eGp00uZmi8OFzb3cFrE9dG5MfrjRKcGc=",
+        version = "v0.1.0",
     )
     go_repository(
         name = "com_github_pmezard_go_difflib",

examples/finder/main.go

@@ -19,7 +19,7 @@ Mauris feugiat vitae eros et facilisis.
 Donec facilisis mattis dignissim.`,
 	}
 
-	subEng := &finder.PetarDambovalievEngine{}
+	subEng := &finder.CloudflareForkEngine{}
 	rgxEng := &finder.RegexpEngine{}
 	caseSensitive := true
 	findthem := finder.NewFinder(subEng, rgxEng, caseSensitive)
@@ -51,11 +51,11 @@ Donec facilisis mattis dignissim.`,
 		}
 		fmt.Printf("----------Text %d case sensitive-----------\n", i)
 		for _, expRes := range resp {
-			fmt.Printf("exp: [%s]%s | %v\n", expRes.Tag, expRes.ExpresionStr, expRes.Evaluation)
+			fmt.Printf("exp %d: [%s]%s\n", expRes.ExpresionIndex, expRes.Tag, expRes.ExpresionStr)
 		}
 	}
 
-	subEng2 := &finder.PetarDambovalievEngine{}
+	subEng2 := &finder.CloudflareForkEngine{}
 	rgxEng2 := &finder.RegexpEngine{}
 	findthem2 := finder.NewFinder(subEng2, rgxEng2, !caseSensitive)
 
@@ -74,7 +74,7 @@ Donec facilisis mattis dignissim.`,
 		}
 		fmt.Printf("----------Text %d case insensitive-----------\n", i)
 		for _, expRes := range resp {
-			fmt.Printf("exp: [%s]%s | %v\n", expRes.Tag, expRes.ExpresionStr, expRes.Evaluation)
+			fmt.Printf("exp %d: [%s]%s\n", expRes.ExpresionIndex, expRes.Tag, expRes.ExpresionStr)
 		}
 	}
 }

finder/BUILD.bazel

@@ -13,7 +13,7 @@ go_library(
         "//dsl",
         "@com_github_anknown_ahocorasick//:ahocorasick",
         "@com_github_cloudflare_ahocorasick//:ahocorasick",
-        "@com_github_petar_dambovaliev_aho_corasick//:aho-corasick",
+        "@com_github_pedroegsilva_ahocorasick//ahocorasick",
     ],
 )
 

finder/finder.go

@@ -23,9 +23,9 @@ type exprWrapper struct {
 
 // ExpressionResult
 type ExpressionResult struct {
-	ExpresionStr string
-	Tag          string
-	Evaluation   bool
+	ExpresionIndex int
+	ExpresionStr   string
+	Tag            string
 }
 
 // Finder stores the needed information to find the terms and solve the expressions
@@ -62,6 +62,33 @@ func (finder *Finder) AddExpression(expression string) error {
 	return finder.AddExpressionWithTag(expression, "")
 }
 
+// AddExpressions adds the expressions to the finder. It also collect
+// and store the terms from all expressions that are going to be used by
+// the substring engine If the expression is malformed returns an error.
+func (finder *Finder) AddExpressions(expressions []string) error {
+	for _, expression := range expressions {
+		err := finder.AddExpressionWithTag(expression, "")
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// AddExpressionsWithTag adds the expressions to the finder with the same tag.
+// the tag will be returned on the process text. It also collect
+// and store the terms that are going to be used by the substring engine
+// If the expression is malformed returns an error.
+func (finder *Finder) AddExpressionsWithTag(expressions []string, tag string) error {
+	for _, expression := range expressions {
+		err := finder.AddExpressionWithTag(expression, tag)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // AddExpressionWithTag adds the expression to the finder with a tag.
 // the tag will be returned on the process text. It also collect
 // and store the terms that are going to be used by the substring engine
@@ -89,7 +116,7 @@ func (finder *Finder) AddExpressionWithTag(expression string, tag string) error
 
 // ProcessText uses all the unique terms to create the substring engine.
 // Searches for matching terms and solves the expressions.
-// and returns a map with the expression string as key and its evaluation as value
+// and returns an array of ExpressionResult for the all expressions that were evaluetad as true.
 func (finder *Finder) ProcessText(text string) (expRes []ExpressionResult, err error) {
 	if !finder.caseSensitive {
 		text = strings.ToLower(text)
@@ -149,18 +176,20 @@ func (finder *Finder) addMatchesToSolverMap(matches []*Match, sortedMatchesByKey
 	}
 }
 
-// solveExpressions solves all expressions using the values of the solverMap
+// solveExpressions returns all expressions that were true using the values of the solverMap
 func (finder *Finder) solveExpressions(sortedMatchesByKeyword map[string][]int) (expRes []ExpressionResult, err error) {
-	expRes = make([]ExpressionResult, len(finder.expressions))
+	expRes = make([]ExpressionResult, 0)
 	for i, exp := range finder.expressions {
 		res, err := exp.solverOrd.Solve(sortedMatchesByKeyword)
 		if err != nil {
 			return nil, err
 		}
-		expRes[i] = ExpressionResult{
-			Evaluation:   res,
-			Tag:          exp.tag,
-			ExpresionStr: exp.exprString,
+		if res {
+			expRes = append(expRes, ExpressionResult{
+				Tag:            exp.tag,
+				ExpresionStr:   exp.exprString,
+				ExpresionIndex: i,
+			})
 		}
 	}
 	return