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() *cobra.Command {
 38	env := execenv.NewEnv()
 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			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,compact,id,json,org-mode]")
 99	cmd.RegisterFlagCompletionFunc("format",
100		completion.From([]string{"default", "plain", "compact", "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(), selectGroup)
111	addCmdWithGroup(newBugSelectCommand(), selectGroup)
112
113	cmd.AddCommand(newBugCommentCommand())
114	cmd.AddCommand(newBugLabelCommand())
115	cmd.AddCommand(newBugNewCommand())
116	cmd.AddCommand(newBugRmCommand())
117	cmd.AddCommand(newBugShowCommand())
118	cmd.AddCommand(newBugStatusCommand())
119	cmd.AddCommand(newBugTitleCommand())
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	bugExcerpt := 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		bugExcerpt[i] = b
157	}
158
159	switch opts.outputFormat {
160	case "org-mode":
161		return bugsOrgmodeFormatter(env, bugExcerpt)
162	case "plain":
163		return bugsPlainFormatter(env, bugExcerpt)
164	case "json":
165		return bugsJsonFormatter(env, bugExcerpt)
166	case "compact":
167		return bugsCompactFormatter(env, bugExcerpt)
168	case "id":
169		return bugsIDFormatter(env, bugExcerpt)
170	case "default":
171		return bugsDefaultFormatter(env, bugExcerpt)
172	default:
173		return fmt.Errorf("unknown format %s", opts.outputFormat)
174	}
175}
176
177func repairQuery(args []string) string {
178	for i, arg := range args {
179		split := strings.Split(arg, ":")
180		for j, s := range split {
181			if strings.Contains(s, " ") {
182				split[j] = fmt.Sprintf("\"%s\"", s)
183			}
184		}
185		args[i] = strings.Join(split, ":")
186	}
187	return strings.Join(args, " ")
188}
189
190func bugsJsonFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
191	jsonBugs := make([]cmdjson.BugExcerpt, len(bugExcerpts))
192	for i, b := range bugExcerpts {
193		jsonBug, err := cmdjson.NewBugExcerpt(env.Backend, b)
194		if err != nil {
195			return err
196		}
197		jsonBugs[i] = jsonBug
198	}
199	return env.Out.PrintJSON(jsonBugs)
200}
201
202func bugsCompactFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
203	for _, b := range bugExcerpts {
204		author, err := env.Backend.Identities().ResolveExcerpt(b.AuthorId)
205		if err != nil {
206			return err
207		}
208
209		var labelsTxt strings.Builder
210		for _, l := range b.Labels {
211			lc256 := l.Color().Term256()
212			labelsTxt.WriteString(lc256.Escape())
213			labelsTxt.WriteString("◼")
214			labelsTxt.WriteString(lc256.Unescape())
215		}
216
217		env.Out.Printf("%s %s %s %s %s\n",
218			colors.Cyan(b.Id().Human()),
219			colors.Yellow(b.Status),
220			text.LeftPadMaxLine(strings.TrimSpace(b.Title), 40, 0),
221			text.LeftPadMaxLine(labelsTxt.String(), 5, 0),
222			colors.Magenta(text.TruncateMax(author.DisplayName(), 15)),
223		)
224	}
225	return nil
226}
227
228func bugsIDFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
229	for _, b := range bugExcerpts {
230		env.Out.Println(b.Id().String())
231	}
232
233	return nil
234}
235
236func bugsDefaultFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
237	width := env.Out.Width()
238	widthId := entity.HumanIdLength
239	widthStatus := len("closed")
240	widthComment := 6
241
242	widthRemaining := width -
243		widthId - 1 -
244		widthStatus - 1 -
245		widthComment - 1
246
247	widthTitle := int(float32(widthRemaining-3) * 0.7)
248	if widthTitle < 0 {
249		widthTitle = 0
250	}
251
252	widthRemaining = widthRemaining - widthTitle - 3 - 2
253	widthAuthor := widthRemaining
254
255	for _, b := range bugExcerpts {
256		author, err := env.Backend.Identities().ResolveExcerpt(b.AuthorId)
257		if err != nil {
258			return err
259		}
260
261		var labelsTxt strings.Builder
262		for _, l := range b.Labels {
263			lc256 := l.Color().Term256()
264			labelsTxt.WriteString(lc256.Escape())
265			labelsTxt.WriteString(" ◼")
266			labelsTxt.WriteString(lc256.Unescape())
267		}
268
269		// truncate + pad if needed
270		labelsFmt := text.TruncateMax(labelsTxt.String(), 10)
271		titleFmt := text.LeftPadMaxLine(strings.TrimSpace(b.Title), widthTitle-text.Len(labelsFmt), 0)
272		authorFmt := text.LeftPadMaxLine(author.DisplayName(), widthAuthor, 0)
273
274		comments := fmt.Sprintf("%3d 💬", b.LenComments-1)
275		if b.LenComments-1 <= 0 {
276			comments = ""
277		}
278		if b.LenComments-1 > 999 {
279			comments = "  ∞ 💬"
280		}
281
282		env.Out.Printf("%s\t%s\t%s   %s %s\n",
283			colors.Cyan(b.Id().Human()),
284			colors.Yellow(b.Status),
285			titleFmt+labelsFmt,
286			colors.Magenta(authorFmt),
287			comments,
288		)
289	}
290	return nil
291}
292
293func bugsPlainFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
294	for _, b := range bugExcerpts {
295		env.Out.Printf("%s [%s] %s\n", b.Id().Human(), b.Status, strings.TrimSpace(b.Title))
296	}
297	return nil
298}
299
300func bugsOrgmodeFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
301	// see https://orgmode.org/manual/Tags.html
302	orgTagRe := regexp.MustCompile("[^[:alpha:]_@]")
303	formatTag := func(l bug.Label) string {
304		return orgTagRe.ReplaceAllString(l.String(), "_")
305	}
306
307	formatTime := func(time time.Time) string {
308		return time.Format("[2006-01-02 Mon 15:05]")
309	}
310
311	env.Out.Println("#+TODO: OPEN | CLOSED")
312
313	for _, b := range bugExcerpts {
314		status := strings.ToUpper(b.Status.String())
315
316		var title string
317		if link, ok := b.CreateMetadata["github-url"]; ok {
318			title = fmt.Sprintf("[[%s][%s]]", link, b.Title)
319		} else {
320			title = b.Title
321		}
322
323		author, err := env.Backend.Identities().ResolveExcerpt(b.AuthorId)
324		if err != nil {
325			return err
326		}
327
328		var labels strings.Builder
329		labels.WriteString(":")
330		for i, l := range b.Labels {
331			if i > 0 {
332				labels.WriteString(":")
333			}
334			labels.WriteString(formatTag(l))
335		}
336		labels.WriteString(":")
337
338		env.Out.Printf("* %-6s %s %s %s: %s %s\n",
339			status,
340			b.Id().Human(),
341			formatTime(b.CreateTime()),
342			author.DisplayName(),
343			title,
344			labels.String(),
345		)
346
347		env.Out.Printf("** Last Edited: %s\n", formatTime(b.EditTime()))
348
349		env.Out.Printf("** Actors:\n")
350		for _, element := range b.Actors {
351			actor, err := env.Backend.Identities().ResolveExcerpt(element)
352			if err != nil {
353				return err
354			}
355
356			env.Out.Printf(": %s %s\n",
357				actor.Id().Human(),
358				actor.DisplayName(),
359			)
360		}
361
362		env.Out.Printf("** Participants:\n")
363		for _, element := range b.Participants {
364			participant, err := env.Backend.Identities().ResolveExcerpt(element)
365			if err != nil {
366				return err
367			}
368
369			env.Out.Printf(": %s %s\n",
370				participant.Id().Human(),
371				participant.DisplayName(),
372			)
373		}
374	}
375
376	return nil
377}
378
379// Finish the command flags transformation into the query.Query
380func completeQuery(q *query.Query, opts bugOptions) error {
381	for _, str := range opts.statusQuery {
382		status, err := common.StatusFromString(str)
383		if err != nil {
384			return err
385		}
386		q.Status = append(q.Status, status)
387	}
388
389	q.Author = append(q.Author, opts.authorQuery...)
390	for _, str := range opts.metadataQuery {
391		tokens := strings.Split(str, "=")
392		if len(tokens) < 2 {
393			return fmt.Errorf("no \"=\" in key=value metadata markup")
394		}
395		var pair query.StringPair
396		pair.Key = tokens[0]
397		pair.Value = tokens[1]
398		q.Metadata = append(q.Metadata, pair)
399	}
400	q.Participant = append(q.Participant, opts.participantQuery...)
401	q.Actor = append(q.Actor, opts.actorQuery...)
402	q.Label = append(q.Label, opts.labelQuery...)
403	q.Title = append(q.Title, opts.titleQuery...)
404
405	for _, no := range opts.noQuery {
406		switch no {
407		case "label":
408			q.NoLabel = true
409		default:
410			return fmt.Errorf("unknown \"no\" filter %s", no)
411		}
412	}
413
414	switch opts.sortBy {
415	case "id":
416		q.OrderBy = query.OrderById
417	case "creation":
418		q.OrderBy = query.OrderByCreation
419	case "edit":
420		q.OrderBy = query.OrderByEdit
421	default:
422		return fmt.Errorf("unknown sort flag %s", opts.sortBy)
423	}
424
425	switch opts.sortDirection {
426	case "asc":
427		q.OrderDirection = query.OrderAscending
428	case "desc":
429		q.OrderDirection = query.OrderDescending
430	default:
431		return fmt.Errorf("unknown sort direction %s", opts.sortDirection)
432	}
433
434	return nil
435}