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