1package bugcmd
2
3import (
4 "fmt"
5 "regexp"
6 "strings"
7 "time"
8
9 text "github.com/MichaelMure/go-term-text"
10 "github.com/spf13/cobra"
11
12 "github.com/git-bug/git-bug/cache"
13 "github.com/git-bug/git-bug/commands/cmdjson"
14 "github.com/git-bug/git-bug/commands/completion"
15 "github.com/git-bug/git-bug/commands/execenv"
16 "github.com/git-bug/git-bug/entities/common"
17 "github.com/git-bug/git-bug/entity"
18 "github.com/git-bug/git-bug/query"
19 "github.com/git-bug/git-bug/util/colors"
20)
21
22type bugOptions struct {
23 statusQuery []string
24 authorQuery []string
25 metadataQuery []string
26 participantQuery []string
27 actorQuery []string
28 labelQuery []string
29 titleQuery []string
30 noQuery []string
31 sortBy string
32 sortDirection string
33 outputFormat string
34 outputFormatChanged bool
35}
36
37func NewBugCommand(env *execenv.Env) *cobra.Command {
38 options := bugOptions{}
39
40 cmd := &cobra.Command{
41 Use: "bug [QUERY]",
42 Short: "List bugs",
43 Long: `Display a summary of each bugs.
44
45You can pass an additional query to filter and order the list. This query can be expressed either with a simple query language, flags, a natural language full text search, or a combination of the aforementioned.`,
46 Example: `List open bugs sorted by last edition with a query:
47git bug status:open sort:edit-desc
48
49List closed bugs sorted by creation with flags:
50git bug --status closed --by creation
51
52Do a full text search of all bugs:
53git bug "foo bar" baz
54
55Use queries, flags, and full text search:
56git bug status:open --by creation "foo bar" baz
57`,
58 PreRunE: execenv.LoadBackend(env),
59 RunE: execenv.CloseBackend(env, func(cmd *cobra.Command, args []string) error {
60 options.outputFormatChanged = cmd.Flags().Changed("format")
61 return runBug(env, options, args)
62 }),
63 ValidArgsFunction: completion.Ls(env),
64 }
65
66 flags := cmd.Flags()
67 flags.SortFlags = false
68
69 flags.StringSliceVarP(&options.statusQuery, "status", "s", nil,
70 "Filter by status. Valid values are [open,closed]")
71 cmd.RegisterFlagCompletionFunc("status", completion.From([]string{"open", "closed"}))
72 flags.StringSliceVarP(&options.authorQuery, "author", "a", nil,
73 "Filter by author")
74 flags.StringSliceVarP(&options.metadataQuery, "metadata", "m", nil,
75 "Filter by metadata. Example: github-url=URL")
76 cmd.RegisterFlagCompletionFunc("author", completion.UserForQuery(env))
77 flags.StringSliceVarP(&options.participantQuery, "participant", "p", nil,
78 "Filter by participant")
79 cmd.RegisterFlagCompletionFunc("participant", completion.UserForQuery(env))
80 flags.StringSliceVarP(&options.actorQuery, "actor", "A", nil,
81 "Filter by actor")
82 cmd.RegisterFlagCompletionFunc("actor", completion.UserForQuery(env))
83 flags.StringSliceVarP(&options.labelQuery, "label", "l", nil,
84 "Filter by label")
85 cmd.RegisterFlagCompletionFunc("label", completion.Label(env))
86 flags.StringSliceVarP(&options.titleQuery, "title", "t", nil,
87 "Filter by title")
88 flags.StringSliceVarP(&options.noQuery, "no", "n", nil,
89 "Filter by absence of something. Valid values are [label]")
90 cmd.RegisterFlagCompletionFunc("no", completion.Label(env))
91 flags.StringVarP(&options.sortBy, "by", "b", "creation",
92 "Sort the results by a characteristic. Valid values are [id,creation,edit]")
93 cmd.RegisterFlagCompletionFunc("by", completion.From([]string{"id", "creation", "edit"}))
94 flags.StringVarP(&options.sortDirection, "direction", "d", "asc",
95 "Select the sorting direction. Valid values are [asc,desc]")
96 cmd.RegisterFlagCompletionFunc("direction", completion.From([]string{"asc", "desc"}))
97 flags.StringVarP(&options.outputFormat, "format", "f", "default",
98 "Select the output formatting style. Valid values are [default,plain,id,json,org-mode]")
99 cmd.RegisterFlagCompletionFunc("format",
100 completion.From([]string{"default", "plain", "id", "json", "org-mode"}))
101
102 const selectGroup = "select"
103 cmd.AddGroup(&cobra.Group{ID: selectGroup, Title: "Implicit selection"})
104
105 addCmdWithGroup := func(child *cobra.Command, groupID string) {
106 cmd.AddCommand(child)
107 child.GroupID = groupID
108 }
109
110 addCmdWithGroup(newBugDeselectCommand(env), selectGroup)
111 addCmdWithGroup(newBugSelectCommand(env), selectGroup)
112
113 cmd.AddCommand(newBugCommentCommand(env))
114 cmd.AddCommand(newBugLabelCommand(env))
115 cmd.AddCommand(newBugNewCommand(env))
116 cmd.AddCommand(newBugRmCommand(env))
117 cmd.AddCommand(newBugShowCommand(env))
118 cmd.AddCommand(newBugStatusCommand(env))
119 cmd.AddCommand(newBugTitleCommand(env))
120
121 return cmd
122}
123
124func runBug(env *execenv.Env, opts bugOptions, args []string) error {
125 var q *query.Query
126 var err error
127
128 if len(args) >= 1 {
129 // either the shell or cobra remove the quotes, we need them back for the query parsing
130 assembled := repairQuery(args)
131
132 q, err = query.Parse(assembled)
133 if err != nil {
134 return err
135 }
136 } else {
137 q = query.NewQuery()
138 }
139
140 err = completeQuery(q, opts)
141 if err != nil {
142 return err
143 }
144
145 allIds, err := env.Backend.Bugs().Query(q)
146 if err != nil {
147 return err
148 }
149
150 excerpts := make([]*cache.BugExcerpt, len(allIds))
151 for i, id := range allIds {
152 b, err := env.Backend.Bugs().ResolveExcerpt(id)
153 if err != nil {
154 return err
155 }
156 excerpts[i] = b
157 }
158
159 switch opts.outputFormat {
160 case "default":
161 if opts.outputFormatChanged {
162 return bugsDefaultFormatter(env, excerpts)
163 }
164 if env.Out.IsTerminal() {
165 return bugsDefaultFormatter(env, excerpts)
166 } else {
167 return bugsPlainFormatter(env, excerpts)
168 }
169 case "id":
170 return bugsIDFormatter(env, excerpts)
171 case "plain":
172 return bugsPlainFormatter(env, excerpts)
173 case "json":
174 return bugsJsonFormatter(env, excerpts)
175 case "org-mode":
176 return bugsOrgmodeFormatter(env, excerpts)
177 default:
178 return fmt.Errorf("unknown format %s", opts.outputFormat)
179 }
180}
181
182func repairQuery(args []string) string {
183 for i, arg := range args {
184 split := strings.Split(arg, ":")
185 for j, s := range split {
186 if strings.Contains(s, " ") {
187 split[j] = fmt.Sprintf("\"%s\"", s)
188 }
189 }
190 args[i] = strings.Join(split, ":")
191 }
192 return strings.Join(args, " ")
193}
194
195func bugsJsonFormatter(env *execenv.Env, excerpts []*cache.BugExcerpt) error {
196 jsonBugs := make([]cmdjson.BugExcerpt, len(excerpts))
197 for i, b := range excerpts {
198 jsonBug, err := cmdjson.NewBugExcerpt(env.Backend, b)
199 if err != nil {
200 return err
201 }
202 jsonBugs[i] = jsonBug
203 }
204 return env.Out.PrintJSON(jsonBugs)
205}
206
207func bugsIDFormatter(env *execenv.Env, excerpts []*cache.BugExcerpt) error {
208 for _, b := range excerpts {
209 env.Out.Println(b.Id().String())
210 }
211
212 return nil
213}
214
215func bugsDefaultFormatter(env *execenv.Env, excerpts []*cache.BugExcerpt) error {
216 width := env.Out.Width()
217 widthId := entity.HumanIdLength
218 widthStatus := len("closed")
219 widthComment := 6
220
221 widthRemaining := width -
222 widthId - 1 -
223 widthStatus - 1 -
224 widthComment - 1
225
226 widthTitle := int(float32(widthRemaining-3) * 0.7)
227 if widthTitle < 0 {
228 widthTitle = 0
229 }
230
231 widthRemaining = widthRemaining - widthTitle - 3 - 2
232 widthAuthor := widthRemaining
233
234 for _, b := range excerpts {
235 author, err := env.Backend.Identities().ResolveExcerpt(b.AuthorId)
236 if err != nil {
237 return err
238 }
239
240 var labelsTxt strings.Builder
241 for _, l := range b.Labels {
242 lc256 := l.Color().Term256()
243 labelsTxt.WriteString(lc256.Escape())
244 labelsTxt.WriteString(" ◼")
245 labelsTxt.WriteString(lc256.Unescape())
246 }
247
248 // truncate + pad if needed
249 labelsFmt := text.TruncateMax(labelsTxt.String(), 10)
250 titleFmt := text.LeftPadMaxLine(strings.TrimSpace(b.Title), widthTitle-text.Len(labelsFmt), 0)
251 authorFmt := text.LeftPadMaxLine(author.DisplayName(), widthAuthor, 0)
252
253 comments := fmt.Sprintf("%3d 💬", b.LenComments-1)
254 if b.LenComments-1 <= 0 {
255 comments = ""
256 }
257 if b.LenComments-1 > 999 {
258 comments = " ∞ 💬"
259 }
260
261 env.Out.Printf("%s\t%s\t%s %s %s\n",
262 colors.Cyan(b.Id().Human()),
263 colors.Yellow(b.Status),
264 titleFmt+labelsFmt,
265 colors.Magenta(authorFmt),
266 comments,
267 )
268 }
269 return nil
270}
271
272func bugsPlainFormatter(env *execenv.Env, excerpts []*cache.BugExcerpt) error {
273 for _, b := range excerpts {
274 env.Out.Printf("%s\t%s\t%s\n", b.Id().Human(), b.Status, strings.TrimSpace(b.Title))
275 }
276 return nil
277}
278
279func bugsOrgmodeFormatter(env *execenv.Env, excerpts []*cache.BugExcerpt) error {
280 // see https://orgmode.org/manual/Tags.html
281 orgTagRe := regexp.MustCompile("[^[:alpha:]_@]")
282 formatTag := func(l common.Label) string {
283 return orgTagRe.ReplaceAllString(l.String(), "_")
284 }
285
286 formatTime := func(time time.Time) string {
287 return time.Format("[2006-01-02 Mon 15:05]")
288 }
289
290 env.Out.Println("#+TODO: OPEN | CLOSED")
291
292 for _, b := range excerpts {
293 status := strings.ToUpper(b.Status.String())
294
295 var title string
296 if link, ok := b.CreateMetadata["github-url"]; ok {
297 title = fmt.Sprintf("[[%s][%s]]", link, b.Title)
298 } else {
299 title = b.Title
300 }
301
302 author, err := env.Backend.Identities().ResolveExcerpt(b.AuthorId)
303 if err != nil {
304 return err
305 }
306
307 var labels strings.Builder
308 labels.WriteString(":")
309 for i, l := range b.Labels {
310 if i > 0 {
311 labels.WriteString(":")
312 }
313 labels.WriteString(formatTag(l))
314 }
315 labels.WriteString(":")
316
317 env.Out.Printf("* %-6s %s %s %s: %s %s\n",
318 status,
319 b.Id().Human(),
320 formatTime(b.CreateTime()),
321 author.DisplayName(),
322 title,
323 labels.String(),
324 )
325
326 env.Out.Printf("** Last Edited: %s\n", formatTime(b.EditTime()))
327
328 env.Out.Printf("** Actors:\n")
329 for _, element := range b.Actors {
330 actor, err := env.Backend.Identities().ResolveExcerpt(element)
331 if err != nil {
332 return err
333 }
334
335 env.Out.Printf(": %s %s\n",
336 actor.Id().Human(),
337 actor.DisplayName(),
338 )
339 }
340
341 env.Out.Printf("** Participants:\n")
342 for _, element := range b.Participants {
343 participant, err := env.Backend.Identities().ResolveExcerpt(element)
344 if err != nil {
345 return err
346 }
347
348 env.Out.Printf(": %s %s\n",
349 participant.Id().Human(),
350 participant.DisplayName(),
351 )
352 }
353 }
354
355 return nil
356}
357
358// Finish the command flags transformation into the query.Query
359func completeQuery(q *query.Query, opts bugOptions) error {
360 for _, str := range opts.statusQuery {
361 status, err := common.StatusFromString(str)
362 if err != nil {
363 return err
364 }
365 q.Status = append(q.Status, status)
366 }
367
368 q.Author = append(q.Author, opts.authorQuery...)
369 for _, str := range opts.metadataQuery {
370 tokens := strings.Split(str, "=")
371 if len(tokens) < 2 {
372 return fmt.Errorf("no \"=\" in key=value metadata markup")
373 }
374 var pair query.StringPair
375 pair.Key = tokens[0]
376 pair.Value = tokens[1]
377 q.Metadata = append(q.Metadata, pair)
378 }
379 q.Participant = append(q.Participant, opts.participantQuery...)
380 q.Actor = append(q.Actor, opts.actorQuery...)
381 q.Label = append(q.Label, opts.labelQuery...)
382 q.Title = append(q.Title, opts.titleQuery...)
383
384 for _, no := range opts.noQuery {
385 switch no {
386 case "label":
387 q.NoLabel = true
388 default:
389 return fmt.Errorf("unknown \"no\" filter %s", no)
390 }
391 }
392
393 switch opts.sortBy {
394 case "id":
395 q.OrderBy = query.OrderById
396 case "creation":
397 q.OrderBy = query.OrderByCreation
398 case "edit":
399 q.OrderBy = query.OrderByEdit
400 default:
401 return fmt.Errorf("unknown sort flag %s", opts.sortBy)
402 }
403
404 switch opts.sortDirection {
405 case "asc":
406 q.OrderDirection = query.OrderAscending
407 case "desc":
408 q.OrderDirection = query.OrderDescending
409 default:
410 return fmt.Errorf("unknown sort direction %s", opts.sortDirection)
411 }
412
413 return nil
414}