now passes linting

storage/tootstore.go

@@ -8,22 +8,29 @@ import "sync"
 
 import "github.com/sneak/feta/toot"
 
+// TootStorageBackend is the interface to which storage backends must
+// conform for storing toots
 type TootStorageBackend interface {
 	TootExists(t toot.Toot) bool
 	StoreToot(t toot.Toot) error
 	StoreToots(tc []*toot.Toot) error
 }
 
+// TootFSStorage is a TootStorageBackend that writes to the local
+// filesystem.
 type TootFSStorage struct {
 	root string
 }
 
+// NewTootFSStorage returns a *TootFSStorage for writing toots to the
+// local filesystem
 func NewTootFSStorage(root string) *TootFSStorage {
 	ts := new(TootFSStorage)
 	ts.root = root
 	return ts
 }
 
+// StoreToots writes a slice of pointers to toots to disk
 func (ts *TootFSStorage) StoreToots(tc []*toot.Toot) error {
 	var returnErrors []string
 	for _, item := range tc {
@@ -39,6 +46,9 @@ func (ts *TootFSStorage) StoreToots(tc []*toot.Toot) error {
 	return errors.New(strings.Join(returnErrors, "; "))
 }
 
+// TootExists checks to see if we have already written a toot to disk or
+// not.  Note that the ingester de-dupes with a table in memory so that this
+// will only really get used on app restarts
 func (ts *TootFSStorage) TootExists(t toot.Toot) bool {
 	path := t.DiskStoragePath()
 	full := ts.root + "/" + path
@@ -49,39 +59,45 @@ func (ts *TootFSStorage) TootExists(t toot.Toot) bool {
 	return true
 }
 
+// StoreToot writes a single toot to disk
 func (ts *TootFSStorage) StoreToot(t toot.Toot) error {
 	path := t.DiskStoragePath()
 	full := ts.root + "/" + path
 	return ioutil.WriteFile(full, t.Original, 0644)
 }
 
+// TootMemoryStorage is a TootStorageBackend that just stores all ingested
+// toots in ram forever until the computer fills up and catches fire and explodes
 type TootMemoryStorage struct {
 	sync.Mutex
-	toots map[toot.TootHash]toot.Toot
+	toots map[toot.Hash]toot.Toot
 	//maxSize uint   // FIXME support eviction
 }
 
+// NewTootMemoryStorage returns a *TootMemoryStorage for storing toots in
+// ram forever
 func NewTootMemoryStorage() *TootMemoryStorage {
 	ts := new(TootMemoryStorage)
-	ts.toots = make(map[toot.TootHash]toot.Toot)
+	ts.toots = make(map[toot.Hash]toot.Toot)
 	return ts
 }
 
+// StoreToot saves a single toot into an in-memory hashtable
 func (ts *TootMemoryStorage) StoreToot(t toot.Toot) {
-	th := t.Hash
-	if ts.TootExists(th) {
+	if ts.TootExists(t) {
 		return
 	}
 	ts.Lock()
 	defer ts.Unlock()
-	ts.toots[th] = t
+	ts.toots[t.Hash] = t
 	return
 }
 
-func (ts *TootMemoryStorage) TootExists(th toot.TootHash) bool {
+// TootExists checks to see if we have a toot in memory already
+func (ts *TootMemoryStorage) TootExists(t toot.Toot) bool {
 	ts.Lock()
 	defer ts.Unlock()
-	if _, ok := ts.toots[th]; ok { //this syntax is so gross
+	if _, ok := ts.toots[t.Hash]; ok { //this syntax is so gross
 		return true
 	}
 	return false