signalsciences / ac Goto Github PK

see https://golang.org/pkg/regexp/ for details

and add this to tests.

We are testing the String versions of the functions but not the []byte

Should be easy to add to test harness

The old Match function returned a []int an list of indexes to the original dictionary input.

Redo so it returns the raw [][]byte or a []string or the exact list of what it found. For a few reasons

• matches regexp
• easier to test
• better api -- a different implimentation may not use the original list or keep it around.

For example
https://golang.org/pkg/regexp/#Regexp.FindAllIndex

The original code has a number of minor corrections for latest golang style.

Current Match returns a list of indexes into the original dictionary. We'll change that name to something like FindAll and FindAllString in a different ticket

• Match with return a bool if the input []byte has a match.
• MatchString will return a bool if the input string has a match

To make this as close to regex as possible:

• switch over NewMatcher and NewStringMatcher to Compile, CompileString
• return object and error. Right now, there are no errors but this will future proof the API
  (for example, errors if duplicate items are passed could be don\e)
• Add MustCompile, MustCompileString for ease in testing and matching regexp

The current node struct does something like this

a  bool
b int
c bool

when it could be

a bool
c bool
b int

which saves 8 bytes per instance.

Add TravisCI for automated build/test

acascii version crashes on non-ASCII dictionary. Should return error.

This functions knows the size of the array, but creates an empty holder and uses append.

We can just set the array to the correct size, skipped any re-allocations

func CompileString(dictionary []string) (*Matcher, error) {
        m := new(Matcher)

        var d [][]byte
        for _, s := range dictionary {
                d = append(d, []byte(s))
        }

The dumb way to do case-insentive match is convert to upper-case when creating dictionary, and upper-case when doing a search. However, this using the ToUpper make a copy (even for []byte) and does full UTF-8 case folding which is slow and inappropriate for this use case.

The old assert style looks like something I might have done in 2013 too ;-)
Table-driven is the way to go now days.

Very good coverage however.

the original has comparison between itself vs. regex vs. linear search

maybe a bit excessive now days.

If we do this right, we can use an interface and reuse some code for this vs. regex