2018-07-13 17:13:40 +03:00
|
|
|
package bug
|
2018-07-12 22:31:41 +03:00
|
|
|
|
2018-08-03 00:37:49 +03:00
|
|
|
import (
|
2018-09-29 00:51:47 +03:00
|
|
|
"crypto/sha256"
|
|
|
|
"encoding/json"
|
2018-09-15 14:15:00 +03:00
|
|
|
"fmt"
|
2018-08-03 00:37:49 +03:00
|
|
|
"time"
|
2018-09-29 00:51:47 +03:00
|
|
|
|
|
|
|
"github.com/MichaelMure/git-bug/util/git"
|
|
|
|
"github.com/pkg/errors"
|
2018-08-03 00:37:49 +03:00
|
|
|
)
|
2018-07-18 01:16:06 +03:00
|
|
|
|
2018-09-13 12:13:51 +03:00
|
|
|
// OperationType is an operation type identifier
|
2018-07-12 22:31:41 +03:00
|
|
|
type OperationType int
|
|
|
|
|
|
|
|
const (
|
2018-07-17 20:28:37 +03:00
|
|
|
_ OperationType = iota
|
|
|
|
CreateOp
|
|
|
|
SetTitleOp
|
|
|
|
AddCommentOp
|
|
|
|
SetStatusOp
|
2018-07-18 17:41:09 +03:00
|
|
|
LabelChangeOp
|
2018-09-29 21:41:19 +03:00
|
|
|
EditCommentOp
|
2018-07-12 22:31:41 +03:00
|
|
|
)
|
|
|
|
|
2018-08-13 16:28:16 +03:00
|
|
|
// Operation define the interface to fulfill for an edit operation of a Bug
|
2018-07-12 22:31:41 +03:00
|
|
|
type Operation interface {
|
2018-09-28 21:39:39 +03:00
|
|
|
// base return the OpBase of the Operation, for package internal use
|
|
|
|
base() *OpBase
|
2018-09-29 21:41:19 +03:00
|
|
|
// Hash return the hash of the operation, to be used for back references
|
2018-09-29 00:51:47 +03:00
|
|
|
Hash() (git.Hash, error)
|
2018-08-13 16:28:16 +03:00
|
|
|
// Time return the time when the operation was added
|
2018-07-18 01:16:06 +03:00
|
|
|
Time() time.Time
|
2018-09-10 20:03:17 +03:00
|
|
|
// GetUnixTime return the unix timestamp when the operation was added
|
|
|
|
GetUnixTime() int64
|
2018-09-12 17:57:04 +03:00
|
|
|
// GetFiles return the files needed by this operation
|
|
|
|
GetFiles() []git.Hash
|
2018-09-15 14:15:00 +03:00
|
|
|
// Apply the operation to a Snapshot to create the final state
|
2018-09-29 12:28:18 +03:00
|
|
|
Apply(snapshot *Snapshot)
|
2018-09-15 14:15:00 +03:00
|
|
|
// Validate check if the operation is valid (ex: a title is a single line)
|
|
|
|
Validate() error
|
2018-09-24 21:19:16 +03:00
|
|
|
// SetMetadata store arbitrary metadata about the operation
|
|
|
|
SetMetadata(key string, value string)
|
|
|
|
// GetMetadata retrieve arbitrary metadata about the operation
|
|
|
|
GetMetadata(key string) (string, bool)
|
2018-07-12 22:31:41 +03:00
|
|
|
}
|
2018-07-13 22:21:24 +03:00
|
|
|
|
2018-09-29 00:51:47 +03:00
|
|
|
func hashRaw(data []byte) git.Hash {
|
|
|
|
hasher := sha256.New()
|
2018-09-29 22:09:09 +03:00
|
|
|
// Write can't fail
|
|
|
|
_, _ = hasher.Write(data)
|
2018-09-29 21:41:19 +03:00
|
|
|
return git.Hash(fmt.Sprintf("%x", hasher.Sum(nil)))
|
2018-09-29 00:51:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// hash compute the hash of the serialized operation
|
|
|
|
func hashOperation(op Operation) (git.Hash, error) {
|
|
|
|
base := op.base()
|
|
|
|
|
|
|
|
if base.hash != "" {
|
|
|
|
return base.hash, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
data, err := json.Marshal(op)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
base.hash = hashRaw(data)
|
|
|
|
|
|
|
|
return base.hash, nil
|
|
|
|
}
|
|
|
|
|
2018-08-13 16:28:16 +03:00
|
|
|
// OpBase implement the common code for all operations
|
2018-07-13 22:21:24 +03:00
|
|
|
type OpBase struct {
|
2018-09-29 00:51:47 +03:00
|
|
|
OperationType OperationType `json:"type"`
|
|
|
|
Author Person `json:"author"`
|
|
|
|
UnixTime int64 `json:"timestamp"`
|
|
|
|
hash git.Hash
|
2018-09-24 21:19:16 +03:00
|
|
|
Metadata map[string]string `json:"metadata,omitempty"`
|
2018-07-18 01:16:06 +03:00
|
|
|
}
|
|
|
|
|
2018-09-28 21:39:39 +03:00
|
|
|
// newOpBase is the constructor for an OpBase
|
2018-10-01 12:37:17 +03:00
|
|
|
func newOpBase(opType OperationType, author Person, unixTime int64) OpBase {
|
|
|
|
return OpBase{
|
2018-07-18 01:16:06 +03:00
|
|
|
OperationType: opType,
|
|
|
|
Author: author,
|
2018-09-25 18:56:58 +03:00
|
|
|
UnixTime: unixTime,
|
2018-07-18 01:16:06 +03:00
|
|
|
}
|
2018-07-13 22:21:24 +03:00
|
|
|
}
|
|
|
|
|
2018-08-13 16:28:16 +03:00
|
|
|
// Time return the time when the operation was added
|
2018-09-24 21:19:16 +03:00
|
|
|
func (op *OpBase) Time() time.Time {
|
2018-09-10 20:03:17 +03:00
|
|
|
return time.Unix(op.UnixTime, 0)
|
2018-08-23 20:19:16 +03:00
|
|
|
}
|
|
|
|
|
2018-09-10 20:03:17 +03:00
|
|
|
// GetUnixTime return the unix timestamp when the operation was added
|
2018-09-24 21:19:16 +03:00
|
|
|
func (op *OpBase) GetUnixTime() int64 {
|
2018-09-10 20:03:17 +03:00
|
|
|
return op.UnixTime
|
2018-07-18 01:16:06 +03:00
|
|
|
}
|
2018-08-06 21:31:20 +03:00
|
|
|
|
2018-09-12 17:57:04 +03:00
|
|
|
// GetFiles return the files needed by this operation
|
2018-09-24 21:19:16 +03:00
|
|
|
func (op *OpBase) GetFiles() []git.Hash {
|
2018-08-06 21:31:20 +03:00
|
|
|
return nil
|
|
|
|
}
|
2018-09-15 14:15:00 +03:00
|
|
|
|
|
|
|
// Validate check the OpBase for errors
|
2018-09-28 21:39:39 +03:00
|
|
|
func opBaseValidate(op Operation, opType OperationType) error {
|
|
|
|
if op.base().OperationType != opType {
|
|
|
|
return fmt.Errorf("incorrect operation type (expected: %v, actual: %v)", opType, op.base().OperationType)
|
2018-09-15 14:15:00 +03:00
|
|
|
}
|
|
|
|
|
2018-09-29 21:41:19 +03:00
|
|
|
if _, err := op.Hash(); err != nil {
|
|
|
|
return errors.Wrap(err, "op is not serializable")
|
|
|
|
}
|
|
|
|
|
2018-09-15 14:15:00 +03:00
|
|
|
if op.GetUnixTime() == 0 {
|
|
|
|
return fmt.Errorf("time not set")
|
|
|
|
}
|
|
|
|
|
2018-09-28 21:39:39 +03:00
|
|
|
if err := op.base().Author.Validate(); err != nil {
|
2018-09-15 14:15:00 +03:00
|
|
|
return errors.Wrap(err, "author")
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, hash := range op.GetFiles() {
|
|
|
|
if !hash.IsValid() {
|
|
|
|
return fmt.Errorf("file with invalid hash %v", hash)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2018-09-24 21:19:16 +03:00
|
|
|
|
|
|
|
// SetMetadata store arbitrary metadata about the operation
|
|
|
|
func (op *OpBase) SetMetadata(key string, value string) {
|
|
|
|
if op.Metadata == nil {
|
|
|
|
op.Metadata = make(map[string]string)
|
|
|
|
}
|
|
|
|
|
|
|
|
op.Metadata[key] = value
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetMetadata retrieve arbitrary metadata about the operation
|
|
|
|
func (op *OpBase) GetMetadata(key string) (string, bool) {
|
|
|
|
val, ok := op.Metadata[key]
|
|
|
|
return val, ok
|
|
|
|
}
|