From b41f3554dad170e03780c05c597f410080ca92c1 Mon Sep 17 00:00:00 2001
From: Seebs <seebs@molecula.com>
Date: Mon, 27 Sep 2021 11:34:46 -0500
Subject: [PATCH] move stableTranslator into test code

It was useful having this in the package to verify code coverage of
the translator, but that having been verified, I'd sort of rather have
it NOT live in the package at all, it's really a testing-only kind
of thing.
---
 ingest/translate.go      | 86 ----------------------------------------
 ingest/translate_test.go | 67 +++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 86 deletions(-)
 delete mode 100644 ingest/translate.go

diff --git a/ingest/translate.go b/ingest/translate.go
deleted file mode 100644
index 42f61e291..000000000
--- a/ingest/translate.go
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2021 Molecula Corp.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package ingest
-
-import (
-	"fmt"
-)
-
-// stableTranslator implements a key translator that can be reused and
-// will continue to give the same keys for the same values. Possibly
-// surprisingly, it will invent new keys for IDs it is asked about but
-// hasn't seen. This allows us to give a codec which would use keys on
-// translation a request which contains arbitrary numbers, and request
-// text that would parse into that request.
-type stableTranslator struct {
-	in   map[string]uint64
-	out  map[uint64]string
-	next uint64
-}
-
-func (s *stableTranslator) TranslateKeys(keys ...string) (map[string]uint64, error) {
-	ret := make(map[string]uint64, len(keys))
-	for _, key := range keys {
-		if existing, ok := s.in[key]; ok {
-			ret[key] = existing
-			continue
-		}
-		id := s.next
-		// but what if someone already translated that ID, so now it already
-		// exists?
-		if _, ok := s.out[id]; ok {
-			for k := range s.out {
-				if k > id {
-					id = k
-				}
-			}
-			// one larger than the largest we already have. this could
-			// wrap around, in which case, it's your own fault.
-			id++
-		}
-		s.next = id + 1
-		s.in[key] = id
-		s.out[id] = key
-		ret[key] = id
-	}
-	return ret, nil
-}
-
-func (s *stableTranslator) TranslateIDs(ids ...uint64) (map[uint64]string, error) {
-	ret := make(map[uint64]string, len(ids))
-	for _, id := range ids {
-		if existing, ok := s.out[id]; ok {
-			ret[id] = existing
-			continue
-		}
-		key := fmt.Sprintf("k-%d", id)
-		s.in[key] = id
-		s.out[id] = key
-		ret[id] = key
-		if id >= s.next {
-			s.next = id + 1
-		}
-	}
-	return ret, nil
-}
-
-// newStableTranslator produces a translator which can translate forwards
-// and backwards and invent new things if it needs to. Don't use this.
-func newStableTranslator() *stableTranslator {
-	return &stableTranslator{
-		in:  make(map[string]uint64),
-		out: make(map[uint64]string),
-	}
-}
diff --git a/ingest/translate_test.go b/ingest/translate_test.go
index 78deefda7..67daf73c3 100644
--- a/ingest/translate_test.go
+++ b/ingest/translate_test.go
@@ -19,6 +19,73 @@ import (
 	"testing"
 )
 
+// stableTranslator implements a key translator that can be reused and
+// will continue to give the same keys for the same values. Possibly
+// surprisingly, it will invent new keys for IDs it is asked about but
+// hasn't seen. This allows us to give a codec which would use keys on
+// translation a request which contains arbitrary numbers, and request
+// text that would parse into that request.
+type stableTranslator struct {
+	in   map[string]uint64
+	out  map[uint64]string
+	next uint64
+}
+
+func (s *stableTranslator) TranslateKeys(keys ...string) (map[string]uint64, error) {
+	ret := make(map[string]uint64, len(keys))
+	for _, key := range keys {
+		if existing, ok := s.in[key]; ok {
+			ret[key] = existing
+			continue
+		}
+		id := s.next
+		// but what if someone already translated that ID, so now it already
+		// exists?
+		if _, ok := s.out[id]; ok {
+			for k := range s.out {
+				if k > id {
+					id = k
+				}
+			}
+			// one larger than the largest we already have. this could
+			// wrap around, in which case, it's your own fault.
+			id++
+		}
+		s.next = id + 1
+		s.in[key] = id
+		s.out[id] = key
+		ret[key] = id
+	}
+	return ret, nil
+}
+
+func (s *stableTranslator) TranslateIDs(ids ...uint64) (map[uint64]string, error) {
+	ret := make(map[uint64]string, len(ids))
+	for _, id := range ids {
+		if existing, ok := s.out[id]; ok {
+			ret[id] = existing
+			continue
+		}
+		key := fmt.Sprintf("k-%d", id)
+		s.in[key] = id
+		s.out[id] = key
+		ret[id] = key
+		if id >= s.next {
+			s.next = id + 1
+		}
+	}
+	return ret, nil
+}
+
+// newStableTranslator produces a translator which can translate forwards
+// and backwards and invent new things if it needs to. Don't use this.
+func newStableTranslator() *stableTranslator {
+	return &stableTranslator{
+		in:  make(map[string]uint64),
+		out: make(map[uint64]string),
+	}
+}
+
 func TestTranslateReuse(t *testing.T) {
 	// the original stable-translator design had a flaw in that it
 	// assumed that each new ID would always come from a string translation,