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