Remember multiple patterns with the same id

Author: jsmorph

pruner/pruner.go

@@ -247,11 +247,11 @@ func (m *Matcher) MatchesForFields(fields []quamina.Field) ([]quamina.X, error)
 	// read lock here.
 	var emitted, filtered int64
 	for _, x := range xs {
-		have, err := m.live.Get(x)
+		have, err := m.live.Contains(x)
 		if err != nil {
 			return nil, err
 		}
-		if have == "" {
+		if !have {
 			filtered++
 			continue
 		}

pruner/pruner_test.go

@@ -293,8 +293,8 @@ func (s *badState) Add(x quamina.X, pattern string) error {
 	return s.err
 }
 
-func (s *badState) Get(x quamina.X) (string, error) {
-	return "", s.err
+func (s *badState) Contains(x quamina.X) (bool, error) {
+	return false, s.err
 }
 
 func (s *badState) Delete(x quamina.X) (bool, error) {
@@ -383,3 +383,47 @@ func TestFlattener(t *testing.T) {
 	}
 
 }
+
+func TestMultiplePatternsWithSameId(t *testing.T) {
+	var (
+		m              = NewMatcher(nil)
+		id interface{} = 1
+	)
+
+	if err := m.AddPattern(id, `{"enjoys":["queso"]}`); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := m.AddPattern(id, `{"needs":["chips"]}`); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := m.Rebuild(false); err != nil {
+		t.Fatal(err)
+	}
+
+	// If we weren't able to remember that both patterns are still
+	// live, then one of the two checks below will fail.  In that
+	// case, we can't tell which one in advance (because Go map
+	// iteration order is not specified).
+
+	xs, err := m.MatchesForJSONEvent([]byte(`{"enjoys":"queso"}`))
+
+	check := func() {
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(xs) != id {
+			t.Fatal(xs)
+		}
+		if xs[0] != id {
+			t.Fatal(xs)
+		}
+	}
+
+	check()
+
+	xs, err = m.MatchesForJSONEvent([]byte(`{"needs":"chips"}`))
+
+	check()
+}

pruner/state.go

@@ -11,51 +11,66 @@ import (
 // of live patterns.
 type State interface {
 	// Add adds a new pattern or updates an old pattern.
+	//
+	// Note that multiple patterns can be associated with the same
+	// X.
 	Add(x quamina.X, pattern string) error
 
 	Delete(x quamina.X) (bool, error)
 
 	// Iterate calls the given function for every stored pattern.
 	Iterate(func(x quamina.X, pattern string) error) error
 
-	// Get returns the pattern for the given X.
+	// Contains returns true if x is in the live set; false
+	// otherwise.
 	//
 	// Since a pattern can't be the empty string, that zero value
 	// indicates no corresponding pattern.
-	Get(x quamina.X) (string, error)
+	Contains(x quamina.X) (bool, error)
 }
 
+type (
+	stringSet map[string]nothing
+	nothing   struct{}
+)
+
+var na = nothing{}
+
 // MemState is a State that is just a map (with a RWMutex).
 //
 // Since the State implementation can be provided to the
 // application, we're keeping things simple here initially.
 type MemState struct {
 	lock sync.RWMutex
-	m    map[quamina.X]string
+	m    map[quamina.X]stringSet
 }
 
 func NewMemState() *MemState {
 	// Accept initial size as a parameter?
 	return &MemState{
-		m: make(map[quamina.X]string),
+		m: make(map[quamina.X]stringSet),
 	}
 }
 
 var ErrExists = fmt.Errorf("pattern already exists for that X")
 
 func (s *MemState) Add(x quamina.X, pattern string) error {
 	s.lock.Lock()
-	// We don't care if the X is already there.
-	s.m[x] = pattern
+	ps, have := s.m[x]
+	if !have {
+		ps = make(stringSet)
+		s.m[x] = ps
+	}
+	ps[pattern] = na
 	s.lock.Unlock()
 	return nil
 }
 
-func (s *MemState) Get(x quamina.X) (string, error) {
+func (s *MemState) Contains(x quamina.X) (bool, error) {
 	s.lock.RLock()
-	p := s.m[x]
+	_, have := s.m[x]
 	s.lock.RUnlock()
-	return p, nil
+	return have, nil
 }
 
 func (s *MemState) Delete(x quamina.X) (bool, error) {
@@ -72,9 +87,11 @@ func (s *MemState) Delete(x quamina.X) (bool, error) {
 func (s *MemState) Iterate(f func(x quamina.X, pattern string) error) error {
 	s.lock.RLock()
 	var err error
-	for x, p := range s.m {
-		if err = f(x, p); err != nil {
-			break
+	for x, ps := range s.m {
+		for p := range ps {
+			if err = f(x, p); err != nil {
+				break
+			}
 		}
 	}
 	s.lock.RUnlock()