1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
package bug
import (
"crypto/sha256"
"encoding/json"
"fmt"
"time"
"github.com/MichaelMure/git-bug/identity"
"github.com/MichaelMure/git-bug/util/git"
"github.com/pkg/errors"
)
// OperationType is an operation type identifier
type OperationType int
const (
_ OperationType = iota
CreateOp
SetTitleOp
AddCommentOp
SetStatusOp
LabelChangeOp
EditCommentOp
NoOpOp
SetMetadataOp
)
// Operation define the interface to fulfill for an edit operation of a Bug
type Operation interface {
// base return the OpBase of the Operation, for package internal use
base() *OpBase
// Hash return the hash of the operation, to be used for back references
Hash() (git.Hash, error)
// Time return the time when the operation was added
Time() time.Time
// GetUnixTime return the unix timestamp when the operation was added
GetUnixTime() int64
// GetFiles return the files needed by this operation
GetFiles() []git.Hash
// Apply the operation to a Snapshot to create the final state
Apply(snapshot *Snapshot)
// Validate check if the operation is valid (ex: a title is a single line)
Validate() error
// SetMetadata store arbitrary metadata about the operation
SetMetadata(key string, value string)
// GetMetadata retrieve arbitrary metadata about the operation
GetMetadata(key string) (string, bool)
// AllMetadata return all metadata for this operation
AllMetadata() map[string]string
}
func hashRaw(data []byte) git.Hash {
hasher := sha256.New()
// Write can't fail
_, _ = hasher.Write(data)
return git.Hash(fmt.Sprintf("%x", hasher.Sum(nil)))
}
// 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
}
// TODO: serialization with identity
// OpBase implement the common code for all operations
type OpBase struct {
OperationType OperationType
Author identity.Interface
UnixTime int64
Metadata map[string]string
// Not serialized. Store the op's hash in memory.
hash git.Hash
// Not serialized. Store the extra metadata in memory,
// compiled from SetMetadataOperation.
extraMetadata map[string]string
}
// newOpBase is the constructor for an OpBase
func newOpBase(opType OperationType, author identity.Interface, unixTime int64) OpBase {
return OpBase{
OperationType: opType,
Author: author,
UnixTime: unixTime,
}
}
type opBaseJson struct {
OperationType OperationType `json:"type"`
UnixTime int64 `json:"timestamp"`
Metadata map[string]string `json:"metadata,omitempty"`
}
func (op *OpBase) MarshalJSON() ([]byte, error) {
return json.Marshal(opBaseJson{
OperationType: op.OperationType,
UnixTime: op.UnixTime,
Metadata: op.Metadata,
})
}
func (op *OpBase) UnmarshalJSON(data []byte) error {
aux := opBaseJson{}
if err := json.Unmarshal(data, &aux); err != nil {
return err
}
op.OperationType = aux.OperationType
op.UnixTime = aux.UnixTime
op.Metadata = aux.Metadata
return nil
}
// Time return the time when the operation was added
func (op *OpBase) Time() time.Time {
return time.Unix(op.UnixTime, 0)
}
// GetUnixTime return the unix timestamp when the operation was added
func (op *OpBase) GetUnixTime() int64 {
return op.UnixTime
}
// GetFiles return the files needed by this operation
func (op *OpBase) GetFiles() []git.Hash {
return nil
}
// Validate check the OpBase for errors
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)
}
if _, err := op.Hash(); err != nil {
return errors.Wrap(err, "op is not serializable")
}
if op.GetUnixTime() == 0 {
return fmt.Errorf("time not set")
}
if op.base().Author == nil {
return fmt.Errorf("author not set")
}
if err := op.base().Author.Validate(); err != nil {
return errors.Wrap(err, "author")
}
for _, hash := range op.GetFiles() {
if !hash.IsValid() {
return fmt.Errorf("file with invalid hash %v", hash)
}
}
return nil
}
// 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
op.hash = ""
}
// GetMetadata retrieve arbitrary metadata about the operation
func (op *OpBase) GetMetadata(key string) (string, bool) {
val, ok := op.Metadata[key]
if ok {
return val, true
}
// extraMetadata can't replace the original operations value if any
val, ok = op.extraMetadata[key]
return val, ok
}
// AllMetadata return all metadata for this operation
func (op *OpBase) AllMetadata() map[string]string {
result := make(map[string]string)
for key, val := range op.extraMetadata {
result[key] = val
}
// Original metadata take precedence
for key, val := range op.Metadata {
result[key] = val
}
return result
}
|
