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