From ec67fe7f2f71fea8d642203dd4b7daa30c5814d5 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Fri, 6 Sep 2024 23:28:19 +0300 Subject: rename ent to entry --- internal/client/tui/submit.go | 4 +- internal/server/handler/handler.go | 4 +- internal/server/repository/repository.go | 62 +++++++------- internal/server/repository/repository_test.go | 114 +++++++++++++------------- internal/types/entry_test.go | 64 +++++++-------- 5 files changed, 124 insertions(+), 124 deletions(-) (limited to 'internal') diff --git a/internal/client/tui/submit.go b/internal/client/tui/submit.go index 0610036..cc1ff0d 100644 --- a/internal/client/tui/submit.go +++ b/internal/client/tui/submit.go @@ -34,12 +34,12 @@ func submitEntry(ctx context.Context, conf client.ClientConfig, composeFile stri return errors.New("no server configured") } - ent, err := types.NewEntryFromTextFile(composeFile) + entry, err := types.NewEntryFromTextFile(composeFile) if err != nil { return err } - if err := easyhttp.PostData(ctx, "submit", conf.APIKey, &ent, conf.Servers...); err != nil { + if err := easyhttp.PostData(ctx, "submit", conf.APIKey, &entry, conf.Servers...); err != nil { return err } diff --git a/internal/server/handler/handler.go b/internal/server/handler/handler.go index b834dd0..a108f93 100644 --- a/internal/server/handler/handler.go +++ b/internal/server/handler/handler.go @@ -31,11 +31,11 @@ func (h Handler) Submit(ctx context.Context, w http.ResponseWriter, r *http.Requ return err } - ent, err := types.NewEntry(bytes) + entry, err := types.NewEntry(bytes) if err != nil { return err } - return repository.Instance(h.conf).Merge(ent) + return repository.Instance(h.conf).Merge(entry) } func (h Handler) List(w http.ResponseWriter, r *http.Request) error { diff --git a/internal/server/repository/repository.go b/internal/server/repository/repository.go index 8d2279a..a86f3b8 100644 --- a/internal/server/repository/repository.go +++ b/internal/server/repository/repository.go @@ -66,9 +66,9 @@ func (r Repository) Next(platform types.PlatformName) (types.Entry, bool) { r.mu.Lock() defer r.mu.Unlock() - for _, ent := range r.entries { - if !ent.IsShared(platform) { - return ent, true + for _, entry := range r.entries { + if !entry.IsShared(platform) { + return entry, true } } @@ -96,14 +96,14 @@ func (r Repository) load() error { continue } - ent, err := types.NewEntry(bytes) + entry, err := types.NewEntry(bytes) if err != nil { errs = append(errs, err) continue } r.mu.Lock() - r.entries[ent.ID] = ent + r.entries[entry.ID] = entry r.mu.Unlock() } @@ -123,8 +123,8 @@ func (r Repository) List() ([]entryPair, error) { r.mu.Lock() defer r.mu.Unlock() - for _, ent := range r.entries { - pairs = append(pairs, entryPair{ent.ID, ent.Checksum()}) + for _, entry := range r.entries { + pairs = append(pairs, entryPair{entry.ID, entry.Checksum()}) } return pairs, nil @@ -141,16 +141,16 @@ func (r Repository) ListBytes() ([]byte, error) { // put writes exact the same entry to the repository. Whereas merge // Is a bit more refined, tries to merge the same entry wich are slightly // different into the same entry. -func (r Repository) put(ent types.Entry) error { +func (r Repository) put(entry types.Entry) error { r.mu.Lock() defer r.mu.Unlock() - r.entries[ent.ID] = ent + r.entries[entry.ID] = entry - bytes, err := ent.JSONMarshal() + bytes, err := entry.JSONMarshal() if err != err { return err } - return r.fs.WriteFile(r.entryPath(ent), bytes) + return r.fs.WriteFile(r.entryPath(entry), bytes) } func (r Repository) Get(id types.EntryID) (types.Entry, error) { @@ -164,20 +164,20 @@ func (r Repository) Get(id types.EntryID) (types.Entry, error) { r.mu.Lock() defer r.mu.Unlock() - ent, ok := r.entries[id] + entry, ok := r.entries[id] if !ok { - return ent, fmt.Errorf("no entry with id %s found", id) + return entry, fmt.Errorf("no entry with id %s found", id) } - return ent, nil + return entry, nil } func (r Repository) GetJSON(id types.EntryID) (string, error) { - ent, err := r.Get(id) + entry, err := r.Get(id) if err != nil { return "", err } - bytes, err := ent.JSONMarshal() + bytes, err := entry.JSONMarshal() if err != nil { return "", err } @@ -189,8 +189,8 @@ func (r Repository) hasSameEntry(pair entryPair) bool { r.mu.Lock() defer r.mu.Unlock() - ent, ok := r.entries[pair.ID] - if !ok || ent.Checksum() != pair.Checksum { + entry, ok := r.entries[pair.ID] + if !ok || entry.Checksum() != pair.Checksum { return false } return true @@ -213,30 +213,30 @@ func (r Repository) Merge(otherEnt types.Entry) error { r.mu.Lock() defer r.mu.Unlock() - ent, ok := r.entries[otherEnt.ID] + entry, ok := r.entries[otherEnt.ID] if !ok { log.Println("can't find entry with ID", otherEnt.ID, "in local db, create new from copy") var err error - if ent, err = types.NewEntryFromCopy(otherEnt); err != nil { + if entry, err = types.NewEntryFromCopy(otherEnt); err != nil { return err } } var changed bool - ent, changed, _ = ent.Update(otherEnt) - r.entries[otherEnt.ID] = ent + entry, changed, _ = entry.Update(otherEnt) + r.entries[otherEnt.ID] = entry if !changed { // Hasn't changed, so no need to write anything to file. return nil } - bytes, err := ent.JSONMarshal() + bytes, err := entry.JSONMarshal() if err != err { return err } - return r.fs.WriteFile(r.entryPath(ent), bytes) + return r.fs.WriteFile(r.entryPath(entry), bytes) } func (r Repository) MergeRemotely(ctx context.Context) error { @@ -266,9 +266,9 @@ func (r Repository) mergeRemotelyFromPartner(ctx context.Context, partner string return easyhttp.GetData(ctx, uri, r.conf.APIKey, pairs) } - getEntry := func(ctx context.Context, partner, id types.EntryID, ent *types.Entry) error { + getEntry := func(ctx context.Context, partner, id types.EntryID, entry *types.Entry) error { uri := fmt.Sprintf("%s/get?id=%s", partner, id) - return easyhttp.GetData(ctx, uri, r.conf.APIKey, ent) + return easyhttp.GetData(ctx, uri, r.conf.APIKey, entry) } return r.mergeFromPartner(ctx, partner, getPair, getEntry) @@ -297,19 +297,19 @@ func (r Repository) mergeFromPartner(ctx context.Context, partner string, log.Println("pair", pair, "missing in local reposotory, going to merge it") - var ent types.Entry - if err := getEntry(ctx, partner, pair.ID, &ent); err != nil { + var entry types.Entry + if err := getEntry(ctx, partner, pair.ID, &entry); err != nil { errs = append(errs, err) continue } // In theory, this should never happen - if pair.ID != ent.ID { - errs = append(errs, fmt.Errorf("pair ID %s does not match entry id %s", pair.ID, ent.ID)) + if pair.ID != entry.ID { + errs = append(errs, fmt.Errorf("pair ID %s does not match entry id %s", pair.ID, entry.ID)) continue } - errs = append(errs, r.Merge(ent)) + errs = append(errs, r.Merge(entry)) } return errors.Join(errs...) diff --git a/internal/server/repository/repository_test.go b/internal/server/repository/repository_test.go index c35d7f2..348abb8 100644 --- a/internal/server/repository/repository_test.go +++ b/internal/server/repository/repository_test.go @@ -16,15 +16,15 @@ func TestRepositoryPutGet(t *testing.T) { fs := make(vfs.MemoryFS) repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs) - for _, ent := range makeEntries(t) { - t.Run(ent.ID, func(t *testing.T) { - _ = repo.put(ent) - entGot, err := repo.Get(ent.ID) + for _, entry := range makeEntries(t) { + t.Run(entry.ID, func(t *testing.T) { + _ = repo.put(entry) + entGot, err := repo.Get(entry.ID) if err != nil { t.Error(err) } - if !entGot.Equals(ent) { - t.Error("expected to get", ent, "but got", entGot) + if !entGot.Equals(entry) { + t.Error("expected to get", entry, "but got", entGot) } }) } @@ -38,9 +38,9 @@ func TestRepositoryLoad(t *testing.T) { entries := makeEntries(t) // Write entries into the VFS - for _, ent := range entries { - bytes, _ := ent.JSONMarshal() - _ = repo.fs.WriteFile(repo.entryPath(ent), bytes) + for _, entry := range entries { + bytes, _ := entry.JSONMarshal() + _ = repo.fs.WriteFile(repo.entryPath(entry), bytes) } // Load entries from VFS into the repo @@ -48,14 +48,14 @@ func TestRepositoryLoad(t *testing.T) { t.Error(err) } - for _, ent := range entries { - t.Run(ent.ID, func(t *testing.T) { - entGot, err := repo.Get(ent.ID) + for _, entry := range entries { + t.Run(entry.ID, func(t *testing.T) { + entGot, err := repo.Get(entry.ID) if err != nil { t.Error(err) } - if !entGot.Equals(ent) { - t.Error("expected to get", ent, "but got", entGot) + if !entGot.Equals(entry) { + t.Error("expected to get", entry, "but got", entGot) } }) } @@ -68,8 +68,8 @@ func TestRepositoryList(t *testing.T) { repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs) entries := makeEntries(t) - for _, ent := range entries { - _ = repo.put(ent) + for _, entry := range entries { + _ = repo.put(entry) } pairs, _ := repo.List() @@ -77,17 +77,17 @@ func TestRepositoryList(t *testing.T) { t.Error("expected as many entries as pairs") } - for _, ent := range entries { + for _, entry := range entries { var found bool for _, pair := range pairs { - if ent.ID == pair.ID && ent.Checksum() == pair.Checksum { + if entry.ID == pair.ID && entry.Checksum() == pair.Checksum { found = true - t.Log("entry matches pair", ent, pair) + t.Log("entry matches pair", entry, pair) break } } if !found { - t.Error("could not find entry", ent, "in", pairs) + t.Error("could not find entry", entry, "in", pairs) } } } @@ -97,10 +97,10 @@ func TestRepositoryHasSameEntry(t *testing.T) { fs := make(vfs.MemoryFS) repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs) - ent, _ := makeAnEntry() - _ = repo.put(ent) + entry, _ := makeAnEntry() + _ = repo.put(entry) - pair := entryPair{ent.ID, ent.Checksum()} + pair := entryPair{entry.ID, entry.Checksum()} if !repo.hasSameEntry(pair) { t.Error("repo does not contain entry corresponding to pair", pair) } @@ -116,16 +116,16 @@ func TestRepositoryMerge(t *testing.T) { fs := make(vfs.MemoryFS) repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs) - ent1, _ := makeAnEntry() - _ = repo.put(ent1) + entry1, _ := makeAnEntry() + _ = repo.put(entry1) - ent2, _ := makeAnotherEntry() + entry2, _ := makeAnotherEntry() // Need to have the same IDs so that the entries will actually be merged - ent2.ID = ent1.ID - // Merge a modified ent2 into the repository. - ent2.Body = "merged" - ent2.Epoch = 12345 - _ = repo.Merge(ent2) + entry2.ID = entry1.ID + // Merge a modified entry2 into the repository. + entry2.Body = "merged" + entry2.Epoch = 12345 + _ = repo.Merge(entry2) pairs, _ := repo.List() // Ensuring the merge didn't add a new entry @@ -133,7 +133,7 @@ func TestRepositoryMerge(t *testing.T) { t.Error("expected exactly one element in the repo but got", pairs) } - entGot, _ := repo.Get(ent1.ID) + entGot, _ := repo.Get(entry1.ID) if entGot.Body != "merged" { t.Error("unexpected body", entGot.Body) } @@ -148,10 +148,10 @@ func TestRepositoryMergeFromPartner(t *testing.T) { fs2 := make(vfs.MemoryFS) repo2 := newRepository(server.ServerConfig{DataDir: "./data2"}, fs2) - ent1, _ := makeAnEntry() - _ = repo1.put(ent1) - ent2, _ := makeAnotherEntry() - _ = repo2.put(ent2) + entry1, _ := makeAnEntry() + _ = repo1.put(entry1) + entry2, _ := makeAnotherEntry() + _ = repo2.put(entry2) getPair := func(ctx context.Context, partner string, pairs *[]entryPair) error { var ( @@ -175,7 +175,7 @@ func TestRepositoryMergeFromPartner(t *testing.T) { return nil } - getEntry := func(ctx context.Context, partner, id string, ent *types.Entry) error { + getEntry := func(ctx context.Context, partner, id string, entry *types.Entry) error { var ( ent_ types.Entry err error @@ -191,9 +191,9 @@ func TestRepositoryMergeFromPartner(t *testing.T) { if err != nil { return err } - *ent = ent_ + *entry = ent_ - t.Log("got entry", *ent, "from repo", partner) + t.Log("got entry", *entry, "from repo", partner) return nil } @@ -205,21 +205,21 @@ func TestRepositoryMergeFromPartner(t *testing.T) { } for _, pair := range pairs { - ent1, err := repo1.Get(pair.ID) + entry1, err := repo1.Get(pair.ID) if err != nil { return err } - ent2, err := repo2.Get(pair.ID) + entry2, err := repo2.Get(pair.ID) if err != nil { return err } t.Log("comparing entries") - t.Log("ent1", ent1) - t.Log("ent2", ent2) + t.Log("entry1", entry1) + t.Log("entry2", entry2) - if !ent1.Equals(ent2) { - return fmt.Errorf("entries ent1 and ent2 don't equal") + if !entry1.Equals(entry2) { + return fmt.Errorf("entries entry1 and entry2 don't equal") } } @@ -245,25 +245,25 @@ func TestRepositoryMergeFromPartner(t *testing.T) { }) t.Run("Change shared flag and merge to partner", func(t *testing.T) { - ent, err := repo1.Get(ent1.ID) + entry, err := repo1.Get(entry1.ID) if err != nil { t.Error(err) } // Validate the correct test setup - if ent.IsShared("LinkedIn") { + if entry.IsShared("LinkedIn") { t.Error("for the test expected LinkedIn not to be shared") } // Simulate that the entry was shared to LinkedIn social media! - linkedIn, ok := ent.Shared["LinkedIn"] + linkedIn, ok := entry.Shared["LinkedIn"] if !ok { t.Error("expected to have a LinkedIn shared entry") } linkedIn.Is = true - ent.Shared["LinkedIn"] = linkedIn + entry.Shared["LinkedIn"] = linkedIn - if err := repo1.Update(ent); err != nil { + if err := repo1.Update(entry); err != nil { t.Error(err) } @@ -301,12 +301,12 @@ func TestRepositoryNext(t *testing.T) { repo := newRepository(server.ServerConfig{DataDir: "./data"}, fs) entries := makeEntries(t) - for _, ent := range entries { - _ = repo.put(ent) + for _, entry := range entries { + _ = repo.put(entry) } - if ent, ok := repo.Next("Mastodon"); ok { - t.Error("expected no Mastodon entry to be found", ent) + if entry, ok := repo.Next("Mastodon"); ok { + t.Error("expected no Mastodon entry to be found", entry) } if _, ok := repo.Next("LinkedIn"); !ok { @@ -319,15 +319,15 @@ func TestRepositoryNext(t *testing.T) { } func makeEntries(t *testing.T) []types.Entry { - ent1, err := makeAnEntry() + entry1, err := makeAnEntry() if err != nil { t.Error(err) } - ent2, err := makeAnotherEntry() + entry2, err := makeAnotherEntry() if err != nil { t.Error(err) } - return []types.Entry{ent1, ent2} + return []types.Entry{entry1, entry2} } func makeAnEntry() (types.Entry, error) { diff --git a/internal/types/entry_test.go b/internal/types/entry_test.go index 95d7a8c..a329ec7 100644 --- a/internal/types/entry_test.go +++ b/internal/types/entry_test.go @@ -5,7 +5,7 @@ import ( ) func oneEntry() (Entry, error) { - ent := ` + entry := ` { "body": "Body text here", "shared": { @@ -14,11 +14,11 @@ func oneEntry() (Entry, error) { } } ` - return NewEntry([]byte(ent)) + return NewEntry([]byte(entry)) } func anotherEntry() (Entry, error) { - ent := ` + entry := ` { "body": "Body text here", "shared": { @@ -28,32 +28,32 @@ func anotherEntry() (Entry, error) { } } ` - return NewEntry([]byte(ent)) + return NewEntry([]byte(entry)) } -func twoDifferentEntries() (ent1, ent2 Entry, err error) { - if ent1, err = oneEntry(); err != nil { +func twoDifferentEntries() (entry1, entry2 Entry, err error) { + if entry1, err = oneEntry(); err != nil { return } - ent2, err = anotherEntry() + entry2, err = anotherEntry() return } func TestNewEntryFromJSON(t *testing.T) { - ent1, err := oneEntry() + entry1, err := oneEntry() if err != nil { t.Error(err) return } - t.Log("ent1", ent1) - if len(ent1.Shared) != 2 { - t.Error("expected to have two shared entries in ent1") + t.Log("entry1", entry1) + if len(entry1.Shared) != 2 { + t.Error("expected to have two shared entries in entry1") } - if !ent1.IsShared("Foo") { + if !entry1.IsShared("Foo") { t.Error("Foo should be shared") } - if ent1.IsShared("Bar") { + if entry1.IsShared("Bar") { t.Error("Bar should not be shared") } } @@ -61,71 +61,71 @@ func TestNewEntryFromJSON(t *testing.T) { func TestEntryChecksum(t *testing.T) { t.Parallel() - ent, err := NewEntry([]byte(`{"Body": "Body text here"}`)) + entry, err := NewEntry([]byte(`{"Body": "Body text here"}`)) if err != nil { t.Error(err) return } expected := "4dbd4f04d7917b1f1bd0807cf39a260efe51085d49b40469fca27b7f89cc73bd" - got := ent.Checksum() + got := entry.Checksum() if expected != got { t.Errorf("expected checksum '%s' but got '%s'", expected, got) return } - t.Log(ent.Checksum()) + t.Log(entry.Checksum()) } func TestEquals(t *testing.T) { t.Parallel() - ent1, ent2, err := twoDifferentEntries() + entry1, entry2, err := twoDifferentEntries() if err != nil { t.Error(err) return } - if ent1.Equals(ent2) { - t.Error("entries should not be equal", ent1, ent2) + if entry1.Equals(entry2) { + t.Error("entries should not be equal", entry1, entry2) } - t.Log("both entries differ", ent1, ent2) + t.Log("both entries differ", entry1, entry2) } func TestNewEntryFromCopy(t *testing.T) { - ent1, _, err := twoDifferentEntries() + entry1, _, err := twoDifferentEntries() if err != nil { t.Error(err) } - ent2, err := NewEntryFromCopy(ent1) + entry2, err := NewEntryFromCopy(entry1) if err != nil { t.Error(err) } - if !ent1.Equals(ent2) { - t.Error("copy of entry ent1 does not equal") - t.Error("original:", ent1) - t.Error("copy: ", ent2) + if !entry1.Equals(entry2) { + t.Error("copy of entry entry1 does not equal") + t.Error("original:", entry1) + t.Error("copy: ", entry2) } } func TestUpdate(t *testing.T) { t.Parallel() - ent1, ent2, err := twoDifferentEntries() + entry1, entry2, err := twoDifferentEntries() if err != nil { t.Error(err) } var changed bool - if ent1, changed, err = ent1.Update(ent2); err != nil { + if entry1, changed, err = entry1.Update(entry2); err != nil { t.Error(err) } - if len(ent1.Shared) != 3 { - t.Error("expected 3 entries after update", ent1) + if len(entry1.Shared) != 3 { + t.Error("expected 3 entries after update", entry1) } if !changed { @@ -133,13 +133,13 @@ func TestUpdate(t *testing.T) { } var sharedCount int - for _, shared := range ent1.Shared { + for _, shared := range entry1.Shared { if shared.Is { sharedCount++ } } if sharedCount != 2 { - t.Error("expected 2 shared entries after update but got", sharedCount, ent1) + t.Error("expected 2 shared entries after update but got", sharedCount, entry1) } } -- cgit v1.2.3