1package termui
2
3import (
4 "bytes"
5 "fmt"
6 "strings"
7
8 "github.com/MichaelMure/go-term-text"
9 "github.com/awesome-gocui/gocui"
10 "github.com/dustin/go-humanize"
11
12 "github.com/MichaelMure/git-bug/cache"
13 "github.com/MichaelMure/git-bug/entity"
14 "github.com/MichaelMure/git-bug/query"
15 "github.com/MichaelMure/git-bug/util/colors"
16)
17
18const bugTableView = "bugTableView"
19const bugTableHeaderView = "bugTableHeaderView"
20const bugTableFooterView = "bugTableFooterView"
21const bugTableInstructionView = "bugTableInstructionView"
22
23const defaultRemote = "origin"
24const defaultQuery = "status:open"
25
26type bugTable struct {
27 repo *cache.RepoCache
28 queryStr string
29 query *query.Query
30 allIds []entity.Id
31 excerpts []*cache.BugExcerpt
32 pageCursor int
33 selectCursor int
34}
35
36func newBugTable(c *cache.RepoCache) *bugTable {
37 q, err := query.Parse(defaultQuery)
38 if err != nil {
39 panic(err)
40 }
41
42 return &bugTable{
43 repo: c,
44 query: q,
45 queryStr: defaultQuery,
46 pageCursor: 0,
47 selectCursor: 0,
48 }
49}
50
51func (bt *bugTable) layout(g *gocui.Gui) error {
52 maxX, maxY := g.Size()
53
54 if maxY < 4 {
55 // window too small !
56 return nil
57 }
58
59 v, err := g.SetView(bugTableHeaderView, -1, -1, maxX, 3, 0)
60
61 if err != nil {
62 if !gocui.IsUnknownView(err) {
63 return err
64 }
65
66 v.Frame = false
67 }
68
69 v.Clear()
70 bt.renderHeader(v, maxX)
71
72 v, err = g.SetView(bugTableView, -1, 1, maxX, maxY-3, 0)
73
74 if err != nil {
75 if !gocui.IsUnknownView(err) {
76 return err
77 }
78
79 v.Frame = false
80 v.SelBgColor = gocui.ColorWhite
81 v.SelFgColor = gocui.ColorBlack
82 }
83
84 _, viewHeight := v.Size()
85 err = bt.paginate(viewHeight)
86 if err != nil {
87 return err
88 }
89
90 err = bt.cursorClamp(v)
91 if err != nil {
92 return err
93 }
94
95 v.Clear()
96 bt.render(v, maxX)
97
98 v, err = g.SetView(bugTableFooterView, -1, maxY-4, maxX, maxY, 0)
99
100 if err != nil {
101 if !gocui.IsUnknownView(err) {
102 return err
103 }
104
105 v.Frame = false
106 }
107
108 v.Clear()
109 bt.renderFooter(v, maxX)
110
111 v, err = g.SetView(bugTableInstructionView, -1, maxY-2, maxX, maxY, 0)
112
113 if err != nil {
114 if !gocui.IsUnknownView(err) {
115 return err
116 }
117
118 v.Frame = false
119 v.BgColor = gocui.ColorBlue
120
121 _, _ = fmt.Fprintf(v, "[q] Quit [s] Search [←↓↑→,hjkl] Navigation [↵] Open bug [n] New bug [i] Pull [o] Push")
122 }
123
124 _, err = g.SetCurrentView(bugTableView)
125 return err
126}
127
128func (bt *bugTable) keybindings(g *gocui.Gui) error {
129 // Quit
130 if err := g.SetKeybinding(bugTableView, 'q', gocui.ModNone, quit); err != nil {
131 return err
132 }
133
134 // Down
135 if err := g.SetKeybinding(bugTableView, 'j', gocui.ModNone,
136 bt.cursorDown); err != nil {
137 return err
138 }
139 if err := g.SetKeybinding(bugTableView, gocui.KeyArrowDown, gocui.ModNone,
140 bt.cursorDown); err != nil {
141 return err
142 }
143 // Up
144 if err := g.SetKeybinding(bugTableView, 'k', gocui.ModNone,
145 bt.cursorUp); err != nil {
146 return err
147 }
148 if err := g.SetKeybinding(bugTableView, gocui.KeyArrowUp, gocui.ModNone,
149 bt.cursorUp); err != nil {
150 return err
151 }
152
153 // Previous page
154 if err := g.SetKeybinding(bugTableView, 'h', gocui.ModNone,
155 bt.previousPage); err != nil {
156 return err
157 }
158 if err := g.SetKeybinding(bugTableView, gocui.KeyArrowLeft, gocui.ModNone,
159 bt.previousPage); err != nil {
160 return err
161 }
162 if err := g.SetKeybinding(bugTableView, gocui.KeyPgup, gocui.ModNone,
163 bt.previousPage); err != nil {
164 return err
165 }
166 // Next page
167 if err := g.SetKeybinding(bugTableView, 'l', gocui.ModNone,
168 bt.nextPage); err != nil {
169 return err
170 }
171 if err := g.SetKeybinding(bugTableView, gocui.KeyArrowRight, gocui.ModNone,
172 bt.nextPage); err != nil {
173 return err
174 }
175 if err := g.SetKeybinding(bugTableView, gocui.KeyPgdn, gocui.ModNone,
176 bt.nextPage); err != nil {
177 return err
178 }
179
180 // New bug
181 if err := g.SetKeybinding(bugTableView, 'n', gocui.ModNone,
182 bt.newBug); err != nil {
183 return err
184 }
185
186 // Open bug
187 if err := g.SetKeybinding(bugTableView, gocui.KeyEnter, gocui.ModNone,
188 bt.openBug); err != nil {
189 return err
190 }
191
192 // Pull
193 if err := g.SetKeybinding(bugTableView, 'i', gocui.ModNone,
194 bt.pull); err != nil {
195 return err
196 }
197
198 // Push
199 if err := g.SetKeybinding(bugTableView, 'o', gocui.ModNone,
200 bt.push); err != nil {
201 return err
202 }
203
204 // Query
205 if err := g.SetKeybinding(bugTableView, 's', gocui.ModNone,
206 bt.changeQuery); err != nil {
207 return err
208 }
209
210 return nil
211}
212
213func (bt *bugTable) disable(g *gocui.Gui) error {
214 if err := g.DeleteView(bugTableView); err != nil && !gocui.IsUnknownView(err) {
215 return err
216 }
217 if err := g.DeleteView(bugTableHeaderView); err != nil && !gocui.IsUnknownView(err) {
218 return err
219 }
220 if err := g.DeleteView(bugTableFooterView); err != nil && !gocui.IsUnknownView(err) {
221 return err
222 }
223 if err := g.DeleteView(bugTableInstructionView); err != nil && !gocui.IsUnknownView(err) {
224 return err
225 }
226 return nil
227}
228
229func (bt *bugTable) paginate(max int) error {
230 bt.allIds = bt.repo.QueryBugs(bt.query)
231
232 return bt.doPaginate(max)
233}
234
235func (bt *bugTable) doPaginate(max int) error {
236 // clamp the cursor
237 bt.pageCursor = maxInt(bt.pageCursor, 0)
238 bt.pageCursor = minInt(bt.pageCursor, len(bt.allIds))
239
240 nb := minInt(len(bt.allIds)-bt.pageCursor, max)
241
242 if nb < 0 {
243 bt.excerpts = []*cache.BugExcerpt{}
244 return nil
245 }
246
247 // slice the data
248 ids := bt.allIds[bt.pageCursor : bt.pageCursor+nb]
249
250 bt.excerpts = make([]*cache.BugExcerpt, len(ids))
251
252 for i, id := range ids {
253 excerpt, err := bt.repo.ResolveBugExcerpt(id)
254 if err != nil {
255 return err
256 }
257
258 bt.excerpts[i] = excerpt
259 }
260
261 return nil
262}
263
264func (bt *bugTable) getTableLength() int {
265 return len(bt.excerpts)
266}
267
268func (bt *bugTable) getColumnWidths(maxX int) map[string]int {
269 m := make(map[string]int)
270 m["id"] = 9
271 m["status"] = 7
272
273 left := maxX - 5 - m["id"] - m["status"]
274
275 m["comments"] = 10
276 left -= m["comments"]
277 m["lastEdit"] = 19
278 left -= m["lastEdit"]
279
280 m["author"] = minInt(maxInt(left/3, 15), 10+left/8)
281 m["title"] = maxInt(left-m["author"], 10)
282
283 return m
284}
285
286func (bt *bugTable) render(v *gocui.View, maxX int) {
287 columnWidths := bt.getColumnWidths(maxX)
288
289 for _, excerpt := range bt.excerpts {
290 summaryTxt := fmt.Sprintf("%4d 💬", excerpt.LenComments)
291 if excerpt.LenComments <= 0 {
292 summaryTxt = ""
293 }
294 if excerpt.LenComments > 9999 {
295 summaryTxt = " ∞ 💬"
296 }
297
298 var labelsTxt strings.Builder
299 for _, l := range excerpt.Labels {
300 lc256 := l.Color().Term256()
301 labelsTxt.WriteString(lc256.Escape())
302 labelsTxt.WriteString(" ◼")
303 labelsTxt.WriteString(lc256.Unescape())
304 }
305
306 var authorDisplayName string
307 if excerpt.AuthorId != "" {
308 author, err := bt.repo.ResolveIdentityExcerpt(excerpt.AuthorId)
309 if err != nil {
310 panic(err)
311 }
312 authorDisplayName = author.DisplayName()
313 } else {
314 authorDisplayName = excerpt.LegacyAuthor.DisplayName()
315 }
316
317 lastEditTime := excerpt.EditTime()
318
319 id := text.LeftPadMaxLine(excerpt.Id.Human(), columnWidths["id"], 1)
320 status := text.LeftPadMaxLine(excerpt.Status.String(), columnWidths["status"], 1)
321 labels := text.TruncateMax(labelsTxt.String(), minInt(columnWidths["title"]-2, 10))
322 title := text.LeftPadMaxLine(strings.TrimSpace(excerpt.Title), columnWidths["title"]-text.Len(labels), 1)
323 author := text.LeftPadMaxLine(authorDisplayName, columnWidths["author"], 1)
324 comments := text.LeftPadMaxLine(summaryTxt, columnWidths["comments"], 1)
325 lastEdit := text.LeftPadMaxLine(humanize.Time(lastEditTime), columnWidths["lastEdit"], 1)
326
327 _, _ = fmt.Fprintf(v, "%s %s %s%s %s %s %s\n",
328 colors.Cyan(id),
329 colors.Yellow(status),
330 title,
331 labels,
332 colors.Magenta(author),
333 comments,
334 lastEdit,
335 )
336 }
337
338 _ = v.SetHighlight(bt.selectCursor, true)
339}
340
341func (bt *bugTable) renderHeader(v *gocui.View, maxX int) {
342 columnWidths := bt.getColumnWidths(maxX)
343
344 id := text.LeftPadMaxLine("ID", columnWidths["id"], 1)
345 status := text.LeftPadMaxLine("STATUS", columnWidths["status"], 1)
346 title := text.LeftPadMaxLine("TITLE", columnWidths["title"], 1)
347 author := text.LeftPadMaxLine("AUTHOR", columnWidths["author"], 1)
348 comments := text.LeftPadMaxLine("COMMENTS", columnWidths["comments"], 1)
349 lastEdit := text.LeftPadMaxLine("LAST EDIT", columnWidths["lastEdit"], 1)
350
351 _, _ = fmt.Fprintf(v, "\n")
352 _, _ = fmt.Fprintf(v, "%s %s %s %s %s %s\n", id, status, title, author, comments, lastEdit)
353}
354
355func (bt *bugTable) renderFooter(v *gocui.View, maxX int) {
356 _, _ = fmt.Fprintf(v, " \nShowing %d of %d bugs", len(bt.excerpts), len(bt.allIds))
357}
358
359func (bt *bugTable) cursorDown(g *gocui.Gui, v *gocui.View) error {
360 // If we are at the bottom of the page, switch to the next one.
361 if bt.selectCursor+1 > bt.getTableLength()-1 {
362 _, max := v.Size()
363
364 if bt.pageCursor+max >= len(bt.allIds) {
365 return nil
366 }
367
368 bt.pageCursor += max
369 bt.selectCursor = 0
370
371 return bt.doPaginate(max)
372 }
373
374 bt.selectCursor = minInt(bt.selectCursor+1, bt.getTableLength()-1)
375
376 return nil
377}
378
379func (bt *bugTable) cursorUp(g *gocui.Gui, v *gocui.View) error {
380 // If we are at the top of the page, switch to the previous one.
381 if bt.selectCursor-1 < 0 {
382 _, max := v.Size()
383
384 if bt.pageCursor == 0 {
385 return nil
386 }
387
388 bt.pageCursor = maxInt(0, bt.pageCursor-max)
389 bt.selectCursor = max - 1
390
391 return bt.doPaginate(max)
392 }
393
394 bt.selectCursor = maxInt(bt.selectCursor-1, 0)
395
396 return nil
397}
398
399func (bt *bugTable) cursorClamp(v *gocui.View) error {
400 y := bt.selectCursor
401
402 y = minInt(y, bt.getTableLength()-1)
403 y = maxInt(y, 0)
404
405 bt.selectCursor = y
406
407 return nil
408}
409
410func (bt *bugTable) nextPage(g *gocui.Gui, v *gocui.View) error {
411 _, max := v.Size()
412
413 if bt.pageCursor+max >= len(bt.allIds) {
414 return nil
415 }
416
417 bt.pageCursor += max
418
419 return bt.doPaginate(max)
420}
421
422func (bt *bugTable) previousPage(g *gocui.Gui, v *gocui.View) error {
423 _, max := v.Size()
424
425 if bt.pageCursor == 0 {
426 return nil
427 }
428
429 bt.pageCursor = maxInt(0, bt.pageCursor-max)
430
431 return bt.doPaginate(max)
432}
433
434func (bt *bugTable) newBug(g *gocui.Gui, v *gocui.View) error {
435 return newBugWithEditor(bt.repo)
436}
437
438func (bt *bugTable) openBug(g *gocui.Gui, v *gocui.View) error {
439 if len(bt.excerpts) == 0 {
440 // There are no open bugs, just do nothing
441 return nil
442 }
443 id := bt.excerpts[bt.selectCursor].Id
444 b, err := bt.repo.ResolveBug(id)
445 if err != nil {
446 return err
447 }
448 ui.showBug.SetBug(b)
449 return ui.activateWindow(ui.showBug)
450}
451
452func (bt *bugTable) pull(g *gocui.Gui, v *gocui.View) error {
453 ui.msgPopup.Activate("Pull from remote "+defaultRemote, "...")
454
455 go func() {
456 stdout, err := bt.repo.Fetch(defaultRemote)
457
458 if err != nil {
459 g.Update(func(gui *gocui.Gui) error {
460 ui.msgPopup.Activate(msgPopupErrorTitle, err.Error())
461 return nil
462 })
463 } else {
464 g.Update(func(gui *gocui.Gui) error {
465 ui.msgPopup.UpdateMessage(stdout)
466 return nil
467 })
468 }
469
470 var buffer bytes.Buffer
471 beginLine := ""
472
473 for result := range bt.repo.MergeAll(defaultRemote) {
474 if result.Status == entity.MergeStatusNothing {
475 continue
476 }
477
478 if result.Err != nil {
479 g.Update(func(gui *gocui.Gui) error {
480 ui.msgPopup.Activate(msgPopupErrorTitle, err.Error())
481 return nil
482 })
483 } else {
484 _, _ = fmt.Fprintf(&buffer, "%s%s: %s",
485 beginLine, colors.Cyan(result.Entity.Id().Human()), result,
486 )
487
488 beginLine = "\n"
489
490 g.Update(func(gui *gocui.Gui) error {
491 ui.msgPopup.UpdateMessage(buffer.String())
492 return nil
493 })
494 }
495 }
496
497 _, _ = fmt.Fprintf(&buffer, "%sdone", beginLine)
498
499 g.Update(func(gui *gocui.Gui) error {
500 ui.msgPopup.UpdateMessage(buffer.String())
501 return nil
502 })
503
504 }()
505
506 return nil
507}
508
509func (bt *bugTable) push(g *gocui.Gui, v *gocui.View) error {
510 ui.msgPopup.Activate("Push to remote "+defaultRemote, "...")
511
512 go func() {
513 // TODO: make the remote configurable
514 stdout, err := bt.repo.Push(defaultRemote)
515
516 if err != nil {
517 g.Update(func(gui *gocui.Gui) error {
518 ui.msgPopup.Activate(msgPopupErrorTitle, err.Error())
519 return nil
520 })
521 } else {
522 g.Update(func(gui *gocui.Gui) error {
523 ui.msgPopup.UpdateMessage(stdout)
524 return nil
525 })
526 }
527 }()
528
529 return nil
530}
531
532func (bt *bugTable) changeQuery(g *gocui.Gui, v *gocui.View) error {
533 return editQueryWithEditor(bt)
534}