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(env *execenv.Env) *cobra.Command {
 37	options := bugOptions{}
 38
 39	cmd := &cobra.Command{
 40		Use:   "bug [QUERY]",
 41		Short: "List bugs",
 42		Long: `Display a summary of each bugs.
 43
 44You 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.`,
 45		Example: `List open bugs sorted by last edition with a query:
 46git bug status:open sort:edit-desc
 47
 48List closed bugs sorted by creation with flags:
 49git bug --status closed --by creation
 50
 51Do a full text search of all bugs:
 52git bug "foo bar" baz
 53
 54Use queries, flags, and full text search:
 55git bug status:open --by creation "foo bar" baz
 56`,
 57		PreRunE: execenv.LoadBackend(env),
 58		RunE: execenv.CloseBackend(env, func(cmd *cobra.Command, args []string) error {
 59			return runBug(env, options, args)
 60		}),
 61		ValidArgsFunction: completion.Ls(env),
 62	}
 63
 64	flags := cmd.Flags()
 65	flags.SortFlags = false
 66
 67	flags.StringSliceVarP(&options.statusQuery, "status", "s", nil,
 68		"Filter by status. Valid values are [open,closed]")
 69	cmd.RegisterFlagCompletionFunc("status", completion.From([]string{"open", "closed"}))
 70	flags.StringSliceVarP(&options.authorQuery, "author", "a", nil,
 71		"Filter by author")
 72	flags.StringSliceVarP(&options.metadataQuery, "metadata", "m", nil,
 73		"Filter by metadata. Example: github-url=URL")
 74	cmd.RegisterFlagCompletionFunc("author", completion.UserForQuery(env))
 75	flags.StringSliceVarP(&options.participantQuery, "participant", "p", nil,
 76		"Filter by participant")
 77	cmd.RegisterFlagCompletionFunc("participant", completion.UserForQuery(env))
 78	flags.StringSliceVarP(&options.actorQuery, "actor", "A", nil,
 79		"Filter by actor")
 80	cmd.RegisterFlagCompletionFunc("actor", completion.UserForQuery(env))
 81	flags.StringSliceVarP(&options.labelQuery, "label", "l", nil,
 82		"Filter by label")
 83	cmd.RegisterFlagCompletionFunc("label", completion.Label(env))
 84	flags.StringSliceVarP(&options.titleQuery, "title", "t", nil,
 85		"Filter by title")
 86	flags.StringSliceVarP(&options.noQuery, "no", "n", nil,
 87		"Filter by absence of something. Valid values are [label]")
 88	cmd.RegisterFlagCompletionFunc("no", completion.Label(env))
 89	flags.StringVarP(&options.sortBy, "by", "b", "creation",
 90		"Sort the results by a characteristic. Valid values are [id,creation,edit]")
 91	cmd.RegisterFlagCompletionFunc("by", completion.From([]string{"id", "creation", "edit"}))
 92	flags.StringVarP(&options.sortDirection, "direction", "d", "asc",
 93		"Select the sorting direction. Valid values are [asc,desc]")
 94	cmd.RegisterFlagCompletionFunc("direction", completion.From([]string{"asc", "desc"}))
 95	flags.StringVarP(&options.outputFormat, "format", "f", "default",
 96		"Select the output formatting style. Valid values are [default,plain,compact,id,json,org-mode]")
 97	cmd.RegisterFlagCompletionFunc("format",
 98		completion.From([]string{"default", "plain", "compact", "id", "json", "org-mode"}))
 99
100	const selectGroup = "select"
101	cmd.AddGroup(&cobra.Group{ID: selectGroup, Title: "Implicit selection"})
102
103	addCmdWithGroup := func(child *cobra.Command, groupID string) {
104		cmd.AddCommand(child)
105		child.GroupID = groupID
106	}
107
108	addCmdWithGroup(newBugDeselectCommand(env), selectGroup)
109	addCmdWithGroup(newBugSelectCommand(env), selectGroup)
110
111	cmd.AddCommand(newBugCommentCommand(env))
112	cmd.AddCommand(newBugLabelCommand(env))
113	cmd.AddCommand(newBugNewCommand(env))
114	cmd.AddCommand(newBugRmCommand(env))
115	cmd.AddCommand(newBugShowCommand(env))
116	cmd.AddCommand(newBugStatusCommand(env))
117	cmd.AddCommand(newBugTitleCommand(env))
118
119	return cmd
120}
121
122func runBug(env *execenv.Env, opts bugOptions, args []string) error {
123	var q *query.Query
124	var err error
125
126	if len(args) >= 1 {
127		// either the shell or cobra remove the quotes, we need them back for the query parsing
128		assembled := repairQuery(args)
129
130		q, err = query.Parse(assembled)
131		if err != nil {
132			return err
133		}
134	} else {
135		q = query.NewQuery()
136	}
137
138	err = completeQuery(q, opts)
139	if err != nil {
140		return err
141	}
142
143	allIds, err := env.Backend.Bugs().Query(q)
144	if err != nil {
145		return err
146	}
147
148	bugExcerpt := make([]*cache.BugExcerpt, len(allIds))
149	for i, id := range allIds {
150		b, err := env.Backend.Bugs().ResolveExcerpt(id)
151		if err != nil {
152			return err
153		}
154		bugExcerpt[i] = b
155	}
156
157	switch opts.outputFormat {
158	case "org-mode":
159		return bugsOrgmodeFormatter(env, bugExcerpt)
160	case "plain":
161		return bugsPlainFormatter(env, bugExcerpt)
162	case "json":
163		return bugsJsonFormatter(env, bugExcerpt)
164	case "compact":
165		return bugsCompactFormatter(env, bugExcerpt)
166	case "id":
167		return bugsIDFormatter(env, bugExcerpt)
168	case "default":
169		return bugsDefaultFormatter(env, bugExcerpt)
170	default:
171		return fmt.Errorf("unknown format %s", opts.outputFormat)
172	}
173}
174
175func repairQuery(args []string) string {
176	for i, arg := range args {
177		split := strings.Split(arg, ":")
178		for j, s := range split {
179			if strings.Contains(s, " ") {
180				split[j] = fmt.Sprintf("\"%s\"", s)
181			}
182		}
183		args[i] = strings.Join(split, ":")
184	}
185	return strings.Join(args, " ")
186}
187
188func bugsJsonFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
189	jsonBugs := make([]cmdjson.BugExcerpt, len(bugExcerpts))
190	for i, b := range bugExcerpts {
191		jsonBug, err := cmdjson.NewBugExcerpt(env.Backend, b)
192		if err != nil {
193			return err
194		}
195		jsonBugs[i] = jsonBug
196	}
197	return env.Out.PrintJSON(jsonBugs)
198}
199
200func bugsCompactFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
201	for _, b := range bugExcerpts {
202		author, err := env.Backend.Identities().ResolveExcerpt(b.AuthorId)
203		if err != nil {
204			return err
205		}
206
207		var labelsTxt strings.Builder
208		for _, l := range b.Labels {
209			lc256 := l.Color().Term256()
210			labelsTxt.WriteString(lc256.Escape())
211			labelsTxt.WriteString("◼")
212			labelsTxt.WriteString(lc256.Unescape())
213		}
214
215		env.Out.Printf("%s %s %s %s %s\n",
216			colors.Cyan(b.Id().Human()),
217			colors.Yellow(b.Status),
218			text.LeftPadMaxLine(strings.TrimSpace(b.Title), 40, 0),
219			text.LeftPadMaxLine(labelsTxt.String(), 5, 0),
220			colors.Magenta(text.TruncateMax(author.DisplayName(), 15)),
221		)
222	}
223	return nil
224}
225
226func bugsIDFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
227	for _, b := range bugExcerpts {
228		env.Out.Println(b.Id().String())
229	}
230
231	return nil
232}
233
234func bugsDefaultFormatter(env *execenv.Env, bugExcerpts []*cache.BugExcerpt) error {
235	for _, b := range bugExcerpts {
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), 50-text.Len(labelsFmt), 0)
252		authorFmt := text.LeftPadMaxLine(author.DisplayName(), 15, 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\t%s\t%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, bugExcerpts []*cache.BugExcerpt) error {
274	for _, b := range bugExcerpts {
275		env.Out.Printf("%s [%s] %s\n", b.Id().Human(), b.Status, strings.TrimSpace(b.Title))
276	}
277	return nil
278}
279
280func bugsOrgmodeFormatter(env *execenv.Env, bugExcerpts []*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 bugExcerpts {
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}