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
|
package identity
import (
"crypto/sha256"
"encoding/json"
"fmt"
"strings"
"github.com/MichaelMure/git-bug/repository"
"github.com/MichaelMure/git-bug/util/lamport"
"github.com/MichaelMure/git-bug/util/text"
)
var _ Interface = &Bare{}
// Bare is a very minimal identity, designed to be fully embedded directly along
// other data.
//
// in particular, this identity is designed to be compatible with the handling of
// identities in the early version of git-bug.
type Bare struct {
id string
name string
email string
login string
avatarUrl string
}
func NewBare(name string, email string) *Bare {
return &Bare{name: name, email: email}
}
func NewBareFull(name string, email string, login string, avatarUrl string) *Bare {
return &Bare{name: name, email: email, login: login, avatarUrl: avatarUrl}
}
type bareIdentityJson struct {
Name string `json:"name,omitempty"`
Email string `json:"email,omitempty"`
Login string `json:"login,omitempty"`
AvatarUrl string `json:"avatar_url,omitempty"`
}
func (i *Bare) MarshalJSON() ([]byte, error) {
return json.Marshal(bareIdentityJson{
Name: i.name,
Email: i.email,
Login: i.login,
AvatarUrl: i.avatarUrl,
})
}
func (i *Bare) UnmarshalJSON(data []byte) error {
aux := bareIdentityJson{}
if err := json.Unmarshal(data, &aux); err != nil {
return err
}
i.name = aux.Name
i.email = aux.Email
i.login = aux.Login
i.avatarUrl = aux.AvatarUrl
return nil
}
func (i *Bare) Id() string {
// We don't have a proper ID at hand, so let's hash all the data to get one.
// Hopefully the
if i.id != "" {
return i.id
}
data, err := json.Marshal(i)
if err != nil {
panic(err)
}
h := fmt.Sprintf("%x", sha256.New().Sum(data)[:16])
i.id = string(h)
return i.id
}
func (i *Bare) Name() string {
return i.name
}
func (i *Bare) Email() string {
return i.email
}
func (i *Bare) Login() string {
return i.login
}
func (i *Bare) AvatarUrl() string {
return i.avatarUrl
}
// Keys return the last version of the valid keys
func (i *Bare) Keys() []Key {
return []Key{}
}
// ValidKeysAtTime return the set of keys valid at a given lamport time
func (i *Bare) ValidKeysAtTime(time lamport.Time) []Key {
return []Key{}
}
// DisplayName return a non-empty string to display, representing the
// identity, based on the non-empty values.
func (i *Bare) DisplayName() string {
switch {
case i.name == "" && i.login != "":
return i.login
case i.name != "" && i.login == "":
return i.name
case i.name != "" && i.login != "":
return fmt.Sprintf("%s (%s)", i.name, i.login)
}
panic("invalid person data")
}
// Match tell is the Person match the given query string
func (i *Bare) Match(query string) bool {
query = strings.ToLower(query)
return strings.Contains(strings.ToLower(i.name), query) ||
strings.Contains(strings.ToLower(i.login), query)
}
// Validate check if the Identity data is valid
func (i *Bare) Validate() error {
if text.Empty(i.name) && text.Empty(i.login) {
return fmt.Errorf("either name or login should be set")
}
if strings.Contains(i.name, "\n") {
return fmt.Errorf("name should be a single line")
}
if !text.Safe(i.name) {
return fmt.Errorf("name is not fully printable")
}
if strings.Contains(i.login, "\n") {
return fmt.Errorf("login should be a single line")
}
if !text.Safe(i.login) {
return fmt.Errorf("login is not fully printable")
}
if strings.Contains(i.email, "\n") {
return fmt.Errorf("email should be a single line")
}
if !text.Safe(i.email) {
return fmt.Errorf("email is not fully printable")
}
if i.avatarUrl != "" && !text.ValidUrl(i.avatarUrl) {
return fmt.Errorf("avatarUrl is not a valid URL")
}
return nil
}
// Write the identity into the Repository. In particular, this ensure that
// the Id is properly set.
func (i *Bare) Commit(repo repository.Repo) error {
// Nothing to do, everything is directly embedded
return nil
}
// IsProtected return true if the chain of git commits started to be signed.
// If that's the case, only signed commit with a valid key for this identity can be added.
func (i *Bare) IsProtected() bool {
return false
}
|
