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