1package commands
2
3import (
4 "encoding/json"
5 "fmt"
6 "strings"
7 "time"
8
9 text "github.com/MichaelMure/go-term-text"
10 "github.com/spf13/cobra"
11
12 "github.com/MichaelMure/git-bug/bug"
13 "github.com/MichaelMure/git-bug/cache"
14 "github.com/MichaelMure/git-bug/query"
15 "github.com/MichaelMure/git-bug/util/colors"
16 "github.com/MichaelMure/git-bug/util/interrupt"
17)
18
19var (
20 lsQuery query.Query
21
22 lsStatusQuery []string
23 lsNoQuery []string
24 lsSortBy string
25 lsSortDirection string
26 lsOutputFormat string
27)
28
29func runLsBug(_ *cobra.Command, args []string) error {
30 backend, err := cache.NewRepoCache(repo)
31 if err != nil {
32 return err
33 }
34 defer backend.Close()
35 interrupt.RegisterCleaner(backend.Close)
36
37 var q *query.Query
38 if len(args) >= 1 {
39 q, err = query.Parse(strings.Join(args, " "))
40
41 if err != nil {
42 return err
43 }
44 } else {
45 err = completeQuery()
46 if err != nil {
47 return err
48 }
49 q = &lsQuery
50 }
51
52 allIds := backend.QueryBugs(q)
53
54 bugExcerpt := make([]*cache.BugExcerpt, len(allIds))
55 for i, id := range allIds {
56 b, err := backend.ResolveBugExcerpt(id)
57 if err != nil {
58 return err
59 }
60 bugExcerpt[i] = b
61 }
62
63 switch lsOutputFormat {
64 case "org-mode":
65 return lsOrgmodeFormatter(backend, bugExcerpt)
66 case "plain":
67 return lsPlainFormatter(backend, bugExcerpt)
68 case "json":
69 return lsJsonFormatter(backend, bugExcerpt)
70 case "default":
71 return lsDefaultFormatter(backend, bugExcerpt)
72 default:
73 return fmt.Errorf("unknown format %s", lsOutputFormat)
74 }
75}
76
77type JSONBugExcerpt struct {
78 Id string `json:"id"`
79 HumanId string `json:"human_id"`
80 CreationTime time.Time `json:"creation_time"`
81 LastEdited time.Time `json:"last_edited"`
82
83 Status string `json:"status"`
84 Labels []bug.Label `json:"labels"`
85 Title string `json:"title"`
86 Actors []JSONIdentity `json:"actors"`
87 Participants []JSONIdentity `json:"participants"`
88 Author JSONIdentity `json:"author"`
89
90 Comments int `json:"comments"`
91 Metadata map[string]string `json:"metadata"`
92}
93
94func lsJsonFormatter(backend *cache.RepoCache, bugExcerpts []*cache.BugExcerpt) error {
95 jsonBugs := make([]JSONBugExcerpt, len(bugExcerpts))
96 for i, b := range bugExcerpts {
97 jsonBug := JSONBugExcerpt{
98 b.Id.String(),
99 b.Id.Human(),
100 time.Unix(b.CreateUnixTime, 0),
101 time.Unix(b.EditUnixTime, 0),
102 b.Status.String(),
103 b.Labels,
104 b.Title,
105 []JSONIdentity{},
106 []JSONIdentity{},
107 JSONIdentity{},
108 b.LenComments,
109 b.CreateMetadata,
110 }
111
112 if b.AuthorId != "" {
113 author, err := backend.ResolveIdentityExcerpt(b.AuthorId)
114 if err != nil {
115 return err
116 }
117
118 i, err := NewJSONIdentity(author)
119 if err != nil {
120 return err
121 }
122 jsonBug.Author = i
123 } else {
124 i, err := NewJSONIdentity(b.LegacyAuthor)
125 if err != nil {
126 return err
127 }
128 jsonBug.Author = i
129 }
130
131 for _, element := range b.Actors {
132 actor, err := backend.ResolveIdentityExcerpt(element)
133 if err != nil {
134 return err
135 }
136
137 i, err := NewJSONIdentity(actor)
138 if err != nil {
139 return err
140 }
141
142 jsonBug.Actors = append(jsonBug.Actors, i)
143 }
144
145 for _, element := range b.Participants {
146 participant, err := backend.ResolveIdentityExcerpt(element)
147 if err != nil {
148 return err
149 }
150
151 i, err := NewJSONIdentity(participant)
152 if err != nil {
153 return err
154 }
155
156 jsonBug.Participants = append(jsonBug.Participants, i)
157 }
158
159 jsonBugs[i] = jsonBug
160 }
161 jsonObject, _ := json.MarshalIndent(jsonBugs, "", " ")
162 fmt.Printf("%s\n", jsonObject)
163 return nil
164}
165
166func lsDefaultFormatter(backend *cache.RepoCache, bugExcerpts []*cache.BugExcerpt) error {
167 for _, b := range bugExcerpts {
168 var name string
169 if b.AuthorId != "" {
170 author, err := backend.ResolveIdentityExcerpt(b.AuthorId)
171 if err != nil {
172 return err
173 }
174 name = author.DisplayName()
175 } else {
176 name = b.LegacyAuthor.DisplayName()
177 }
178
179 var labelsTxt strings.Builder
180 for _, l := range b.Labels {
181 lc256 := l.Color().Term256()
182 labelsTxt.WriteString(lc256.Escape())
183 labelsTxt.WriteString(" ◼")
184 labelsTxt.WriteString(lc256.Unescape())
185 }
186
187 // truncate + pad if needed
188 labelsFmt := text.TruncateMax(labelsTxt.String(), 10)
189 titleFmt := text.LeftPadMaxLine(b.Title, 50-text.Len(labelsFmt), 0)
190 authorFmt := text.LeftPadMaxLine(name, 15, 0)
191
192 comments := fmt.Sprintf("%4d 💬", b.LenComments)
193 if b.LenComments > 9999 {
194 comments = " ∞ 💬"
195 }
196
197 fmt.Printf("%s %s\t%s\t%s\t%s\n",
198 colors.Cyan(b.Id.Human()),
199 colors.Yellow(b.Status),
200 titleFmt+labelsFmt,
201 colors.Magenta(authorFmt),
202 comments,
203 )
204 }
205 return nil
206}
207
208func lsPlainFormatter(_ *cache.RepoCache, bugExcerpts []*cache.BugExcerpt) error {
209 for _, b := range bugExcerpts {
210 fmt.Printf("%s [%s] %s\n", b.Id.Human(), b.Status, b.Title)
211 }
212 return nil
213}
214
215func lsOrgmodeFormatter(backend *cache.RepoCache, bugExcerpts []*cache.BugExcerpt) error {
216 fmt.Println("+TODO: OPEN | CLOSED")
217
218 for _, b := range bugExcerpts {
219 status := strings.Title(b.Status.String())
220
221 var title string
222 if link, ok := b.CreateMetadata["github-url"]; ok {
223 title = fmt.Sprintf("[%s][%s]", link, b.Title)
224 } else {
225 title = b.Title
226 }
227
228 var name string
229 if b.AuthorId != "" {
230 author, err := backend.ResolveIdentityExcerpt(b.AuthorId)
231 if err != nil {
232 return err
233 }
234 name = author.DisplayName()
235 } else {
236 name = b.LegacyAuthor.DisplayName()
237 }
238
239 labels := b.Labels
240 var labelsString string
241 if len(labels) > 0 {
242 labelsString = fmt.Sprintf(":%s:", strings.Replace(fmt.Sprint(labels), " ", ":", -1))
243 } else {
244 labelsString = ""
245 }
246
247 fmt.Printf("* %s %s [%s] %s: %s %s\n",
248 b.Id.Human(),
249 status,
250 time.Unix(b.CreateUnixTime, 0),
251 name,
252 title,
253 labelsString,
254 )
255
256 fmt.Printf("** Last Edited: %s\n",
257 time.Unix(b.EditUnixTime, 0).String(),
258 )
259
260 fmt.Printf("** Actors:\n")
261 for _, element := range b.Actors {
262 actor, err := backend.ResolveIdentityExcerpt(element)
263 if err != nil {
264 return err
265 }
266
267 fmt.Printf(": %s %s\n",
268 actor.Id.Human(),
269 actor.DisplayName(),
270 )
271 }
272
273 fmt.Printf("** Participants:\n")
274 for _, element := range b.Participants {
275 participant, err := backend.ResolveIdentityExcerpt(element)
276 if err != nil {
277 return err
278 }
279
280 fmt.Printf(": %s %s\n",
281 participant.Id.Human(),
282 participant.DisplayName(),
283 )
284 }
285 }
286
287 return nil
288}
289
290// Finish the command flags transformation into the query.Query
291func completeQuery() error {
292 for _, str := range lsStatusQuery {
293 status, err := bug.StatusFromString(str)
294 if err != nil {
295 return err
296 }
297 lsQuery.Status = append(lsQuery.Status, status)
298 }
299
300 for _, no := range lsNoQuery {
301 switch no {
302 case "label":
303 lsQuery.NoLabel = true
304 default:
305 return fmt.Errorf("unknown \"no\" filter %s", no)
306 }
307 }
308
309 switch lsSortBy {
310 case "id":
311 lsQuery.OrderBy = query.OrderById
312 case "creation":
313 lsQuery.OrderBy = query.OrderByCreation
314 case "edit":
315 lsQuery.OrderBy = query.OrderByEdit
316 default:
317 return fmt.Errorf("unknown sort flag %s", lsSortBy)
318 }
319
320 switch lsSortDirection {
321 case "asc":
322 lsQuery.OrderDirection = query.OrderAscending
323 case "desc":
324 lsQuery.OrderDirection = query.OrderDescending
325 default:
326 return fmt.Errorf("unknown sort direction %s", lsSortDirection)
327 }
328
329 return nil
330}
331
332var lsCmd = &cobra.Command{
333 Use: "ls [<query>]",
334 Short: "List bugs.",
335 Long: `Display a summary of each bugs.
336
337You can pass an additional query to filter and order the list. This query can be expressed either with a simple query language or with flags.`,
338 Example: `List open bugs sorted by last edition with a query:
339git bug ls status:open sort:edit-desc
340
341List closed bugs sorted by creation with flags:
342git bug ls --status closed --by creation
343`,
344 PreRunE: loadRepo,
345 RunE: runLsBug,
346}
347
348func init() {
349 RootCmd.AddCommand(lsCmd)
350
351 lsCmd.Flags().SortFlags = false
352
353 lsCmd.Flags().StringSliceVarP(&lsStatusQuery, "status", "s", nil,
354 "Filter by status. Valid values are [open,closed]")
355 lsCmd.Flags().StringSliceVarP(&lsQuery.Author, "author", "a", nil,
356 "Filter by author")
357 lsCmd.Flags().StringSliceVarP(&lsQuery.Participant, "participant", "p", nil,
358 "Filter by participant")
359 lsCmd.Flags().StringSliceVarP(&lsQuery.Actor, "actor", "A", nil,
360 "Filter by actor")
361 lsCmd.Flags().StringSliceVarP(&lsQuery.Label, "label", "l", nil,
362 "Filter by label")
363 lsCmd.Flags().StringSliceVarP(&lsQuery.Title, "title", "t", nil,
364 "Filter by title")
365 lsCmd.Flags().StringSliceVarP(&lsNoQuery, "no", "n", nil,
366 "Filter by absence of something. Valid values are [label]")
367 lsCmd.Flags().StringVarP(&lsSortBy, "by", "b", "creation",
368 "Sort the results by a characteristic. Valid values are [id,creation,edit]")
369 lsCmd.Flags().StringVarP(&lsSortDirection, "direction", "d", "asc",
370 "Select the sorting direction. Valid values are [asc,desc]")
371 lsCmd.Flags().StringVarP(&lsOutputFormat, "format", "f", "default",
372 "Select the output formatting style. Valid values are [default,plain,json,org-mode]")
373}