mirror of
https://github.com/MichaelMure/git-bug.git
synced 2024-12-15 10:12:06 +03:00
277 lines
6.2 KiB
Go
277 lines
6.2 KiB
Go
package bug
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
|
|
"github.com/MichaelMure/git-bug/identity"
|
|
"github.com/MichaelMure/git-bug/util/timestamp"
|
|
|
|
"github.com/MichaelMure/git-bug/util/git"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var _ Operation = &LabelChangeOperation{}
|
|
|
|
// LabelChangeOperation define a Bug operation to add or remove labels
|
|
type LabelChangeOperation struct {
|
|
OpBase
|
|
Added []Label
|
|
Removed []Label
|
|
}
|
|
|
|
func (op *LabelChangeOperation) base() *OpBase {
|
|
return &op.OpBase
|
|
}
|
|
|
|
func (op *LabelChangeOperation) Hash() (git.Hash, error) {
|
|
return hashOperation(op)
|
|
}
|
|
|
|
// Apply apply the operation
|
|
func (op *LabelChangeOperation) Apply(snapshot *Snapshot) {
|
|
// Add in the set
|
|
AddLoop:
|
|
for _, added := range op.Added {
|
|
for _, label := range snapshot.Labels {
|
|
if label == added {
|
|
// Already exist
|
|
continue AddLoop
|
|
}
|
|
}
|
|
|
|
snapshot.Labels = append(snapshot.Labels, added)
|
|
}
|
|
|
|
// Remove in the set
|
|
for _, removed := range op.Removed {
|
|
for i, label := range snapshot.Labels {
|
|
if label == removed {
|
|
snapshot.Labels[i] = snapshot.Labels[len(snapshot.Labels)-1]
|
|
snapshot.Labels = snapshot.Labels[:len(snapshot.Labels)-1]
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort
|
|
sort.Slice(snapshot.Labels, func(i, j int) bool {
|
|
return string(snapshot.Labels[i]) < string(snapshot.Labels[j])
|
|
})
|
|
|
|
hash, err := op.Hash()
|
|
if err != nil {
|
|
// Should never error unless a programming error happened
|
|
// (covered in OpBase.Validate())
|
|
panic(err)
|
|
}
|
|
|
|
item := &LabelChangeTimelineItem{
|
|
hash: hash,
|
|
Author: op.Author,
|
|
UnixTime: timestamp.Timestamp(op.UnixTime),
|
|
Added: op.Added,
|
|
Removed: op.Removed,
|
|
}
|
|
|
|
snapshot.Timeline = append(snapshot.Timeline, item)
|
|
}
|
|
|
|
func (op *LabelChangeOperation) Validate() error {
|
|
if err := opBaseValidate(op, LabelChangeOp); err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, l := range op.Added {
|
|
if err := l.Validate(); err != nil {
|
|
return errors.Wrap(err, "added label")
|
|
}
|
|
}
|
|
|
|
for _, l := range op.Removed {
|
|
if err := l.Validate(); err != nil {
|
|
return errors.Wrap(err, "removed label")
|
|
}
|
|
}
|
|
|
|
if len(op.Added)+len(op.Removed) <= 0 {
|
|
return fmt.Errorf("no label change")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Workaround to avoid the inner OpBase.MarshalJSON overriding the outer op
|
|
// MarshalJSON
|
|
func (op *LabelChangeOperation) MarshalJSON() ([]byte, error) {
|
|
base, err := json.Marshal(op.OpBase)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// revert back to a flat map to be able to add our own fields
|
|
var data map[string]interface{}
|
|
if err := json.Unmarshal(base, &data); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data["added"] = op.Added
|
|
data["removed"] = op.Removed
|
|
|
|
return json.Marshal(data)
|
|
}
|
|
|
|
// Workaround to avoid the inner OpBase.MarshalJSON overriding the outer op
|
|
// MarshalJSON
|
|
func (op *LabelChangeOperation) UnmarshalJSON(data []byte) error {
|
|
// Unmarshal OpBase and the op separately
|
|
|
|
base := OpBase{}
|
|
err := json.Unmarshal(data, &base)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
aux := struct {
|
|
Added []Label `json:"added"`
|
|
Removed []Label `json:"removed"`
|
|
}{}
|
|
|
|
err = json.Unmarshal(data, &aux)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
op.OpBase = base
|
|
op.Added = aux.Added
|
|
op.Removed = aux.Removed
|
|
|
|
return nil
|
|
}
|
|
|
|
// Sign post method for gqlgen
|
|
func (op *LabelChangeOperation) IsAuthored() {}
|
|
|
|
func NewLabelChangeOperation(author identity.Interface, unixTime int64, added, removed []Label) *LabelChangeOperation {
|
|
return &LabelChangeOperation{
|
|
OpBase: newOpBase(LabelChangeOp, author, unixTime),
|
|
Added: added,
|
|
Removed: removed,
|
|
}
|
|
}
|
|
|
|
type LabelChangeTimelineItem struct {
|
|
hash git.Hash
|
|
Author identity.Interface
|
|
UnixTime timestamp.Timestamp
|
|
Added []Label
|
|
Removed []Label
|
|
}
|
|
|
|
func (l LabelChangeTimelineItem) Hash() git.Hash {
|
|
return l.hash
|
|
}
|
|
|
|
// ChangeLabels is a convenience function to apply the operation
|
|
func ChangeLabels(b Interface, author identity.Interface, unixTime int64, add, remove []string) ([]LabelChangeResult, *LabelChangeOperation, error) {
|
|
var added, removed []Label
|
|
var results []LabelChangeResult
|
|
|
|
snap := b.Compile()
|
|
|
|
for _, str := range add {
|
|
label := Label(str)
|
|
|
|
// check for duplicate
|
|
if labelExist(added, label) {
|
|
results = append(results, LabelChangeResult{Label: label, Status: LabelChangeDuplicateInOp})
|
|
continue
|
|
}
|
|
|
|
// check that the label doesn't already exist
|
|
if labelExist(snap.Labels, label) {
|
|
results = append(results, LabelChangeResult{Label: label, Status: LabelChangeAlreadySet})
|
|
continue
|
|
}
|
|
|
|
added = append(added, label)
|
|
results = append(results, LabelChangeResult{Label: label, Status: LabelChangeAdded})
|
|
}
|
|
|
|
for _, str := range remove {
|
|
label := Label(str)
|
|
|
|
// check for duplicate
|
|
if labelExist(removed, label) {
|
|
results = append(results, LabelChangeResult{Label: label, Status: LabelChangeDuplicateInOp})
|
|
continue
|
|
}
|
|
|
|
// check that the label actually exist
|
|
if !labelExist(snap.Labels, label) {
|
|
results = append(results, LabelChangeResult{Label: label, Status: LabelChangeDoesntExist})
|
|
continue
|
|
}
|
|
|
|
removed = append(removed, label)
|
|
results = append(results, LabelChangeResult{Label: label, Status: LabelChangeRemoved})
|
|
}
|
|
|
|
if len(added) == 0 && len(removed) == 0 {
|
|
return results, nil, fmt.Errorf("no label added or removed")
|
|
}
|
|
|
|
labelOp := NewLabelChangeOperation(author, unixTime, added, removed)
|
|
|
|
if err := labelOp.Validate(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
b.Append(labelOp)
|
|
|
|
return results, labelOp, nil
|
|
}
|
|
|
|
func labelExist(labels []Label, label Label) bool {
|
|
for _, l := range labels {
|
|
if l == label {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
type LabelChangeStatus int
|
|
|
|
const (
|
|
_ LabelChangeStatus = iota
|
|
LabelChangeAdded
|
|
LabelChangeRemoved
|
|
LabelChangeDuplicateInOp
|
|
LabelChangeAlreadySet
|
|
LabelChangeDoesntExist
|
|
)
|
|
|
|
type LabelChangeResult struct {
|
|
Label Label
|
|
Status LabelChangeStatus
|
|
}
|
|
|
|
func (l LabelChangeResult) String() string {
|
|
switch l.Status {
|
|
case LabelChangeAdded:
|
|
return fmt.Sprintf("label %s added", l.Label)
|
|
case LabelChangeRemoved:
|
|
return fmt.Sprintf("label %s removed", l.Label)
|
|
case LabelChangeDuplicateInOp:
|
|
return fmt.Sprintf("label %s is a duplicate", l.Label)
|
|
case LabelChangeAlreadySet:
|
|
return fmt.Sprintf("label %s was already set", l.Label)
|
|
case LabelChangeDoesntExist:
|
|
return fmt.Sprintf("label %s doesn't exist on this bug", l.Label)
|
|
default:
|
|
panic(fmt.Sprintf("unknown label change status %v", l.Status))
|
|
}
|
|
}
|