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