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