package cache import ( "encoding/gob" "fmt" "github.com/MichaelMure/git-bug/bug" "github.com/MichaelMure/git-bug/entity" "github.com/MichaelMure/git-bug/identity" "github.com/MichaelMure/git-bug/util/lamport" ) // Package initialisation used to register the type for (de)serialization func init() { gob.Register(BugExcerpt{}) } // BugExcerpt hold a subset of the bug values to be able to sort and filter bugs // efficiently without having to read and compile each raw bugs. type BugExcerpt struct { Id entity.Id CreateLamportTime lamport.Time EditLamportTime lamport.Time CreateUnixTime int64 EditUnixTime int64 Status bug.Status Labels []bug.Label Title string LenComments int Actors []entity.Id Participants []entity.Id // If author is identity.Bare, LegacyAuthor is set // If author is identity.Identity, AuthorId is set and data is deported // in a IdentityExcerpt LegacyAuthor LegacyAuthorExcerpt AuthorId entity.Id CreateMetadata map[string]string } // identity.Bare data are directly embedded in the bug excerpt type LegacyAuthorExcerpt struct { Name string Login string } func (l LegacyAuthorExcerpt) DisplayName() string { switch { case l.Name == "" && l.Login != "": return l.Login case l.Name != "" && l.Login == "": return l.Name case l.Name != "" && l.Login != "": return fmt.Sprintf("%s (%s)", l.Name, l.Login) } panic("invalid person data") } func NewBugExcerpt(b bug.Interface, snap *bug.Snapshot) *BugExcerpt { participantsIds := make([]entity.Id, 0, len(snap.Participants)) for _, participant := range snap.Participants { if _, ok := participant.(*identity.Identity); ok { participantsIds = append(participantsIds, participant.Id()) } } actorsIds := make([]entity.Id, 0, len(snap.Actors)) for _, actor := range snap.Actors { if _, ok := actor.(*identity.Identity); ok { actorsIds = append(actorsIds, actor.Id()) } } e := &BugExcerpt{ Id: b.Id(), CreateLamportTime: b.CreateLamportTime(), EditLamportTime: b.EditLamportTime(), CreateUnixTime: b.FirstOp().GetUnixTime(), EditUnixTime: snap.LastEditUnix(), Status: snap.Status, Labels: snap.Labels, Actors: actorsIds, Participants: participantsIds, Title: snap.Title, LenComments: len(snap.Comments), CreateMetadata: b.FirstOp().AllMetadata(), } switch snap.Author.(type) { case *identity.Identity: e.AuthorId = snap.Author.Id() case *identity.Bare: e.LegacyAuthor = LegacyAuthorExcerpt{ Name: snap.Author.Name(), } default: panic("unhandled identity type") } return e } /* * Sorting */ type BugsById []*BugExcerpt func (b BugsById) Len() int { return len(b) } func (b BugsById) Less(i, j int) bool { return b[i].Id < b[j].Id } func (b BugsById) Swap(i, j int) { b[i], b[j] = b[j], b[i] } type BugsByCreationTime []*BugExcerpt func (b BugsByCreationTime) Len() int { return len(b) } func (b BugsByCreationTime) Less(i, j int) bool { if b[i].CreateLamportTime < b[j].CreateLamportTime { return true } if b[i].CreateLamportTime > b[j].CreateLamportTime { return false } // When the logical clocks are identical, that means we had a concurrent // edition. In this case we rely on the timestamp. While the timestamp might // be incorrect due to a badly set clock, the drift in sorting is bounded // by the first sorting using the logical clock. That means that if users // synchronize their bugs regularly, the timestamp will rarely be used, and // should still provide a kinda accurate sorting when needed. return b[i].CreateUnixTime < b[j].CreateUnixTime } func (b BugsByCreationTime) Swap(i, j int) { b[i], b[j] = b[j], b[i] } type BugsByEditTime []*BugExcerpt func (b BugsByEditTime) Len() int { return len(b) } func (b BugsByEditTime) Less(i, j int) bool { if b[i].EditLamportTime < b[j].EditLamportTime { return true } if b[i].EditLamportTime > b[j].EditLamportTime { return false } // When the logical clocks are identical, that means we had a concurrent // edition. In this case we rely on the timestamp. While the timestamp might // be incorrect due to a badly set clock, the drift in sorting is bounded // by the first sorting using the logical clock. That means that if users // synchronize their bugs regularly, the timestamp will rarely be used, and // should still provide a kinda accurate sorting when needed. return b[i].EditUnixTime < b[j].EditUnixTime } func (b BugsByEditTime) Swap(i, j int) { b[i], b[j] = b[j], b[i] }