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
|
package entity
import (
"crypto/sha256"
"fmt"
"io"
"strings"
"github.com/pkg/errors"
)
// sha-256
const idLength = 64
const humanIdLength = 7
const UnsetId = Id("unset")
// Id is an identifier for an entity or part of an entity
type Id string
// DeriveId generate an Id from some data, taken from a root part of the entity.
func DeriveId(data []byte) Id {
// My understanding is that sha256 is enough to prevent collision (git use that, so ...?)
// If you read this code, I'd be happy to be schooled.
sum := sha256.Sum256(data)
return Id(fmt.Sprintf("%x", sum))
}
// String return the identifier as a string
func (i Id) String() string {
return string(i)
}
// Human return the identifier, shortened for human consumption
func (i Id) Human() string {
format := fmt.Sprintf("%%.%ds", humanIdLength)
return fmt.Sprintf(format, i)
}
func (i Id) HasPrefix(prefix string) bool {
return strings.HasPrefix(string(i), prefix)
}
// UnmarshalGQL implement the Unmarshaler interface for gqlgen
func (i *Id) UnmarshalGQL(v interface{}) error {
_, ok := v.(string)
if !ok {
return fmt.Errorf("IDs must be strings")
}
*i = v.(Id)
if err := i.Validate(); err != nil {
return errors.Wrap(err, "invalid ID")
}
return nil
}
// MarshalGQL implement the Marshaler interface for gqlgen
func (i Id) MarshalGQL(w io.Writer) {
_, _ = w.Write([]byte(`"` + i.String() + `"`))
}
// IsValid tell if the Id is valid
func (i Id) Validate() error {
// Special case to detect outdated repo
if len(i) == 40 {
return fmt.Errorf("outdated repository format, please use https://github.com/MichaelMure/git-bug-migration to upgrade")
}
if len(i) != idLength {
return fmt.Errorf("invalid length")
}
for _, r := range i {
if (r < 'a' || r > 'z') && (r < '0' || r > '9') {
return fmt.Errorf("invalid character")
}
}
return nil
}
/*
* Sorting
*/
type Alphabetical []Id
func (a Alphabetical) Len() int {
return len(a)
}
func (a Alphabetical) Less(i, j int) bool {
return a[i] < a[j]
}
func (a Alphabetical) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
|
