fix: Minor fixes in docs and style

Signed-off-by: Michael Gasch <[email protected]>

Author: Michael Gasch

arrays_test.go

@@ -70,7 +70,6 @@ const bands = `{
 }`
 
 func TestArrayCorrectness(t *testing.T) {
-
 	// only pattern3 should match
 	pattern1 := `{"bands": { "members": { "given": [ "Mick" ], "surname": [ "Strummer" ] } } }`
 	pattern2 := `{"bands": { "members": { "given": [ "Wata" ], "role": [ "drums" ] } } }`

benchmarks_test.go

@@ -14,9 +14,11 @@ import (
 
 const oneMeg = 1024 * 1024
 
-var cityLotsLock sync.Mutex
-var cityLotsLines [][]byte
-var cityLotsLineCount int
+var (
+	cityLotsLock      sync.Mutex
+	cityLotsLines     [][]byte
+	cityLotsLineCount int
+)
 
 func getCityLotsLines(t *testing.T) [][]byte {
 	cityLotsLock.Lock()
@@ -47,7 +49,6 @@ func getCityLotsLines(t *testing.T) [][]byte {
 }
 
 func TestCRANLEIGH(t *testing.T) {
-
 	jCranleigh := `{ "type": "Feature", "properties": { "MAPBLKLOT": "7222001", "BLKLOT": "7222001", "BLOCK_NUM": "7222", "LOT_NUM": "001", "FROM_ST": "1", "TO_ST": "1", "STREET": "CRANLEIGH", "ST_TYPE": "DR", "ODD_EVEN": "O" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -122.472773074480756, 37.73439178240811, 0.0 ], [ -122.47278111723567, 37.73451247621523, 0.0 ], [ -122.47242608711845, 37.73452184591072, 0.0 ], [ -122.472418368113281, 37.734401143064396, 0.0 ], [ -122.472773074480756, 37.73439178240811, 0.0 ] ] ] } }`
 	j108492 := `{ "type": "Feature", "properties": { "MAPBLKLOT": "0011008", "BLKLOT": "0011008", "BLOCK_NUM": "0011", "LOT_NUM": "008", "FROM_ST": "500", "TO_ST": "550", "STREET": "BEACH", "ST_TYPE": "ST", "ODD_EVEN": "E" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -122.418114728237924, 37.807058866808987, 0.0 ], [ -122.418261722815416, 37.807807921694092, 0.0 ], [ -122.417544151208375, 37.807900142836701, 0.0 ], [ -122.417397010603693, 37.807150305505004, 0.0 ], [ -122.418114728237924, 37.807058866808987, 0.0 ] ] ] } }`
 	m := newCoreMatcher()

core_matcher.go

@@ -1,10 +1,13 @@
 package quamina
 
-// coreMatcher represents an automaton that allows matching sequences of name/value field pairs against
+// coreMatcher represents an automaton that allows matching sequences of
+// name/value field pairs against
 //  patterns, which are combinations of field names and lists of allowed valued field values.
-// The field names are called "Paths" because they encode, in a jsonpath-ish style, the pathSegments from the
+// The field names are called "Paths" because they encode, in a jsonpath-ish
+// style, the pathSegments from the
 //  root of an incoming object to the leaf field.
-// Since the order of fields is generally not significant in encoded data objects, the fields are sorted
+// Since the order of fields is generally not significant in encoded data
+// objects, the fields are sorted
 //  by name before constructing the automaton, and so are the incoming field lists to be matched, allowing
 //  the automaton to work.
 
@@ -32,9 +35,6 @@ type coreStart struct {
 	presumedExistFalseMatches *matchSet
 }
 
-// X for anything, should eventually be a generic?
-type X any
-
 func newCoreMatcher() *coreMatcher {
 	m := coreMatcher{}
 	m.updateable.Store(&coreStart{
@@ -44,6 +44,7 @@ func newCoreMatcher() *coreMatcher {
 	})
 	return &m
 }
+
 func (m *coreMatcher) start() *coreStart {
 	return m.updateable.Load().(*coreStart)
 }
@@ -146,7 +147,6 @@ type proposedTransition struct {
 // matchesForSortedFields runs the provided list of name/value pairs against the automaton and returns
 //  a possibly-empty list of the patterns that match
 func (m *coreMatcher) matchesForSortedFields(fields []Field) *matchSet {
-
 	failedExistsFalseMatches := newMatchSet()
 	matches := newMatchSet()
 
@@ -203,14 +203,16 @@ func (m *coreMatcher) matchesForSortedFields(fields []Field) *matchSet {
 
 // Arrays are invisible in the automaton.  That is to say, if an event has
 //  { "a": [ 1, 2, 3 ] }
-//  Then the fields will be a/1, a/2, and a/3
-//  Same for  {"a": [[1, 2], 3]} or any other permutation
-//  So if you have {"a": [ { "b": 1, "c": 2}, {"b": 3, "c": 4}] }
-//  then a pattern like { "a": { "b": 1, "c": 4 } } would match.
-// To prevent that from happening, each ArrayPos contains two numbers; the first identifies the array in
-//  the event that this name/val occurred in, the second the position in the array. We don't allow
-//  transitioning between field values that occur in different positions in the same array.
-//  See the arrays_test unit test for more examples.
+// Then the fields will be a/1, a/2, and a/3 Same for  {"a": [[1, 2], 3]} or any
+// other permutation So if you have
+//  {"a": [ { "b": 1, "c": 2}, {"b": 3, "c": 4}] }
+// then a pattern like
+//  { "a": { "b": 1, "c": 4 } }
+// would match. To prevent that from happening, each ArrayPos contains two
+// numbers; the first identifies the array in
+// the event that this name/val occurred in, the second the position in the array. We don't allow
+// transitioning between field values that occur in different positions in the same array.
+// See the arrays_test unit test for more examples.
 func noArrayTrailConflict(from []ArrayPos, to []ArrayPos) bool {
 	for _, fromAPos := range from {
 		for _, toAPos := range to {

external_test.go

@@ -1,8 +1,9 @@
 package quamina_test
 
 import (
-	"github.com/timbray/quamina"
 	"testing"
+
+	"github.com/timbray/quamina"
 )
 
 type fakeFlattener struct {
@@ -12,6 +13,7 @@ type fakeFlattener struct {
 func (f *fakeFlattener) Flatten(_ []byte, _ quamina.NameTracker) ([]quamina.Field, error) {
 	return f.r, nil
 }
+
 func (f *fakeFlattener) Copy() quamina.Flattener {
 	return &fakeFlattener{r: f.r}
 }

field_matcher.go

@@ -25,6 +25,7 @@ type fmFields struct {
 func (m *fieldMatcher) fields() *fmFields {
 	return m.updateable.Load().(*fmFields)
 }
+
 func (m *fieldMatcher) update(fields *fmFields) {
 	m.updateable.Store(fields)
 }
@@ -58,7 +59,6 @@ func newFieldMatcher() *fieldMatcher {
 }
 
 func (m *fieldMatcher) addTransition(field *patternField) []*fieldMatcher {
-
 	// we build the new updateable state in freshStart so we can blsat it in atomically once computed
 	current := m.fields()
 	freshStart := &fmFields{}
@@ -107,7 +107,6 @@ func (m *fieldMatcher) addTransition(field *patternField) []*fieldMatcher {
 //  would be if you had the pattern { "a": [ "foo" ] } and another pattern that matched any value with
 //  a prefix of "f".
 func (m *fieldMatcher) transitionOn(field *Field) []*fieldMatcher {
-
 	// are there transitions on this field name?
 	valMatcher, ok := m.fields().transitions[string(field.Path)]
 	if !ok {

flatten_json.go

@@ -37,8 +37,11 @@ func (fj *flattenJSON) reset() {
 
 // JSON literals
 var trueBytes = []byte("true")
-var falseBytes = []byte("false")
-var nullBytes = []byte("null")
+
+var (
+	falseBytes = []byte("false")
+	nullBytes  = []byte("null")
+)
 
 // fjState - this is a finite state machine parser, or rather a collection of smaller FSM parsers. Some of these
 //  states are used in only one function, others in multiple places
@@ -394,8 +397,8 @@ func (fj *flattenJSON) readNumber() ([]byte, []byte, error) {
 			case ',', ']', '}', ' ', '\t', '\n', '\r':
 				fj.eventIndex--
 				// TODO: Too expensive; make it possible for people to ask for this
-				//bytes := fj.event[numStart : fj.eventIndex+1]
-				//c, err := canonicalize(bytes)
+				// bytes := fj.event[numStart : fj.eventIndex+1]
+				// c, err := canonicalize(bytes)
 				var alt []byte
 				//if err == nil {
 				//	alt = []byte(c)
@@ -457,7 +460,6 @@ func (fj *flattenJSON) readNumber() ([]byte, []byte, error) {
 }
 
 func (fj *flattenJSON) readLiteral(literal []byte) ([]byte, error) {
-
 	for _, literalCh := range literal {
 		if literalCh != fj.ch() {
 			return nil, fj.error("unknown literal")
@@ -496,7 +498,7 @@ func (fj *flattenJSON) readStringValue() ([]byte, error) {
 }
 
 func (fj *flattenJSON) readStringValWithEscapes(nameStart int) ([]byte, error) {
-	//pointing at '"'
+	// pointing at '"'
 	val := []byte{'"'}
 	var err error
 	from := nameStart + 1
@@ -625,7 +627,6 @@ func (fj *flattenJSON) readTextWithEscapes(from int) ([]byte, int, error) {
 // the from is the offset in fj.event. We return the UTF-8 byte slice, the new setting for fj.eventIndex after
 //  reading the escapes, and an error if the escape syntax is busted.
 func (fj *flattenJSON) readHexUTF16(from int) ([]byte, int, error) {
-
 	// in the case that there are multiple \uXXXX in a row, we need to read all of them because some of them
 	//  might be surrogate pairs. So, back up to point at the first \
 	var codepoints []uint16
@@ -701,6 +702,7 @@ func (fj *flattenJSON) storeArrayElementField(path []byte, val []byte) {
 	copy(f.ArrayTrail, fj.arrayTrail)
 	fj.fields = append(fj.fields, f)
 }
+
 func (fj *flattenJSON) storeObjectMemberField(path []byte, arrayTrail []ArrayPos, val []byte) {
 	fj.fields = append(fj.fields, Field{Path: path, ArrayTrail: arrayTrail, Val: val})
 }
@@ -709,9 +711,11 @@ func (fj *flattenJSON) enterArray() {
 	fj.arrayCount++
 	fj.arrayTrail = append(fj.arrayTrail, ArrayPos{fj.arrayCount, 0})
 }
+
 func (fj *flattenJSON) leaveArray() {
 	fj.arrayTrail = fj.arrayTrail[:len(fj.arrayTrail)-1]
 }
+
 func (fj *flattenJSON) stepOneArrayElement() {
 	fj.arrayTrail[len(fj.arrayTrail)-1].Pos++
 }

flatten_json_test.go

@@ -16,13 +16,13 @@ func bequal(a []byte, b []byte) bool {
 	}
 	return true
 }
+
 func TestFJBasic(t *testing.T) {
 	j := `{ "a": 1, "b": "two", "c": true, "d": null, "e": { "e1": 2, "e2": 3.02e-5}, "f": [33e2, "x", true, false, null], "g": false}`
 	allYes := fakeMatcher("a", "b", "c", "d", "e", "e1", "e2", "f", "g")
 
 	f := newJSONFlattener()
 	list, err := f.Flatten([]byte(j), allYes)
-
 	if err != nil {
 		t.Error("E: " + err.Error())
 	}
@@ -56,7 +56,6 @@ func TestFJBasic(t *testing.T) {
 }
 
 func TestFJ10Lines(t *testing.T) {
-
 	geo := fakeMatcher("type", "geometry")
 	testTrackerSelection(newJSONFlattener(), geo, "L0", "testdata/cl-sample-0",
 		[]string{"type", "geometry\ntype"},
@@ -122,6 +121,7 @@ func TestMinimal(t *testing.T) {
 		t.Error("Name/Val wrong")
 	}
 }
+
 func testTrackerSelection(fj Flattener, tracker NameTracker, label string, filename string, wantedPaths []string, wantedVals []string, t *testing.T) {
 	event, err := ioutil.ReadFile(filename)
 	if err != nil {

flattener.go

@@ -1,37 +1,41 @@
 package quamina
 
+// ArrayPos ... TODO
 type ArrayPos struct {
 	Array int32
 	Pos   int32
 }
+
+// Field ... TODO
 type Field struct {
 	Path       []byte
 	Val        []byte
 	ArrayTrail []ArrayPos
 }
 
-// Flattener is provided as an interface in the hope that flatterners for other non-JSON message formats might
-//  be implemented.
-// How it needs to work, by JSON example:
-// { "a": 1, "b": "two", "c": true", "d": nil, "e": { "e1": 2, "e2":, 3.02e-5} "f": [33, "x"]} }
+// Flattener is provided as an interface in the hope that flatterners for other
+// non-JSON message formats might be implemented. How it needs to work, by JSON
+// example:
+//  { "a": 1, "b": "two", "c": true", "d": nil, "e": { "e1": 2, "e2":, 3.02e-5} "f": [33, "x"]} }
 // should produce
-// "a", "1"
-// "b", "\"two\"",
-// "c", "true"
-// "d", "nil",
-// "e\ne1", "2"
-// "e\ne2", "3.02e-5"
-// "f", "33"
-// "f", "\"x\""
+//  "a", "1"
+//  "b", "\"two\"",
+//  "c", "true"
+//  "d", "nil",
+//  "e\ne1", "2"
+//  "e\ne2", "3.02e-5"
+//  "f", "33"
+//  "f", "\"x\""
 //
-// Let's call the first column, eg "d" and "e\ne1", the pathSegments. For each step i the pathSegments, e.g. "d" and "e1", the
-//  Flattener shold call nameTracker.IsNameUsed(step) and if that comes back negative, not include any paths which
-//  don't contain that step.
-// So in the example above, if nameTracker.IsNameUsed() only came back true for "a" and "f", then the output
-//  would be
-// "a", "1"
-// "f", "33"
-// "f", "\"x\""
+// Let's call the first column, eg "d" and "e\ne1", the pathSegments. For each
+// step i the pathSegments, e.g. "d" and "e1", the Flattener shold call
+// nameTracker.IsNameUsed(step) and if that comes back negative, not include any
+// paths which don't contain that step. So in the example above, if
+// nameTracker.IsNameUsed() only came back true for "a" and "f", then the output
+// would be
+//  "a", "1"
+//  "f", "33"
+//  "f", "\"x\""
 type Flattener interface {
 	Flatten(event []byte, tracker NameTracker) ([]Field, error)
 	Copy() Flattener

list_maker_test.go

@@ -48,5 +48,4 @@ func TestListMaker(t *testing.T) {
 	if len(lists) != wanted {
 		t.Errorf("Got %d STILL wanted %d", len(lists), wanted)
 	}
-
 }

live_pattern_state.go

@@ -4,24 +4,22 @@ import (
 	"sync"
 )
 
-// LivePatternsState represents the required capabilities for
-// maintaining the set of live patterns.
+// LivePatternsState represents the required capabilities for maintaining the
+// set of live patterns.
 type LivePatternsState interface {
 	// Add adds a new pattern or updates an old pattern.
 	//
-	// Note that multiple patterns can be associated with the same
-	// X.
+	// Note that multiple patterns can be associated with the same X.
 	Add(x X, pattern string) error
 
-	// Delete removes all patterns associated with the given X and
-	// returns the number of removed patterns.
+	// Delete removes all patterns associated with the given X and returns the
+	// number of removed patterns.
 	Delete(x X) (int, error)
 
 	// Iterate calls the given function for every stored pattern.
 	Iterate(func(x X, pattern string) error) error
 
-	// Contains returns true if x is in the live set; false
-	// otherwise.
+	// Contains returns true if x is in the live set; false otherwise.
 	Contains(x X) (bool, error)
 }
 
@@ -32,8 +30,7 @@ type (
 
 var na = nothing{}
 
-// MemState is a LivePatternsState that is just a map (with a
-// RWMutex).
+// MemState is a LivePatternsState that is just a map (with a RWMutex).
 //
 // Since the LivePatternsState implementation can be provided to the
 // application, we're keeping things simple here initially.