git-bug/termui/show_bug.go

410 lines
8.3 KiB
Go
Raw Normal View History

2018-08-01 03:15:40 +03:00
package termui
import (
"fmt"
2018-08-08 23:22:35 +03:00
2018-08-01 03:15:40 +03:00
"github.com/MichaelMure/git-bug/bug/operations"
"github.com/MichaelMure/git-bug/cache"
"github.com/MichaelMure/git-bug/util"
"github.com/jroimartin/gocui"
)
const showBugView = "showBugView"
const showBugSidebarView = "showBugSidebarView"
const showBugInstructionView = "showBugInstructionView"
const showBugHeaderView = "showBugHeaderView"
2018-08-01 03:15:40 +03:00
const timeLayout = "Jan 2 2006"
2018-08-01 03:15:40 +03:00
type showBug struct {
2018-08-08 23:22:35 +03:00
cache cache.RepoCacher
bug cache.BugCacher
childViews []string
selectableView []string
selected string
scroll int
2018-08-01 03:15:40 +03:00
}
func newShowBug(cache cache.RepoCacher) *showBug {
return &showBug{
cache: cache,
}
}
2018-08-09 15:51:19 +03:00
func (sb *showBug) SetBug(bug cache.BugCacher) {
sb.bug = bug
sb.scroll = 0
}
2018-08-01 03:15:40 +03:00
func (sb *showBug) layout(g *gocui.Gui) error {
maxX, maxY := g.Size()
2018-08-08 23:22:35 +03:00
v, err := g.SetView(showBugView, 0, 0, maxX*2/3, maxY-2)
2018-08-01 03:15:40 +03:00
if err != nil {
if err != gocui.ErrUnknownView {
return err
}
sb.childViews = append(sb.childViews, showBugView)
2018-08-01 03:15:40 +03:00
v.Frame = false
}
v.Clear()
err = sb.renderMain(g, v)
if err != nil {
return err
}
2018-08-01 03:15:40 +03:00
v, err = g.SetView(showBugSidebarView, maxX*2/3+1, 0, maxX-1, maxY-2)
if err != nil {
if err != gocui.ErrUnknownView {
return err
}
sb.childViews = append(sb.childViews, showBugSidebarView)
v.Frame = true
2018-08-01 03:15:40 +03:00
}
v.Clear()
sb.renderSidebar(v)
v, err = g.SetView(showBugInstructionView, -1, maxY-2, maxX, maxY)
if err != nil {
if err != gocui.ErrUnknownView {
return err
}
sb.childViews = append(sb.childViews, showBugInstructionView)
2018-08-01 03:15:40 +03:00
v.Frame = false
v.BgColor = gocui.ColorBlue
fmt.Fprintf(v, "[q] Save and return [c] Comment [t] Change title [↓,j] Down [↑,k] Up")
2018-08-01 03:15:40 +03:00
}
_, err = g.SetCurrentView(showBugView)
return err
}
func (sb *showBug) keybindings(g *gocui.Gui) error {
// Return
if err := g.SetKeybinding(showBugView, 'q', gocui.ModNone, sb.saveAndBack); err != nil {
2018-08-01 03:15:40 +03:00
return err
}
// Scrolling
2018-08-01 03:15:40 +03:00
if err := g.SetKeybinding(showBugView, gocui.KeyPgup, gocui.ModNone,
sb.scrollUp); err != nil {
return err
}
if err := g.SetKeybinding(showBugView, gocui.KeyPgdn, gocui.ModNone,
sb.scrollDown); err != nil {
return err
}
2018-08-08 23:22:35 +03:00
// Down
if err := g.SetKeybinding(showBugView, 'j', gocui.ModNone,
sb.selectNext); err != nil {
return err
}
if err := g.SetKeybinding(showBugView, gocui.KeyArrowDown, gocui.ModNone,
sb.selectNext); err != nil {
return err
}
// Up
if err := g.SetKeybinding(showBugView, 'k', gocui.ModNone,
sb.selectPrevious); err != nil {
return err
}
if err := g.SetKeybinding(showBugView, gocui.KeyArrowUp, gocui.ModNone,
sb.selectPrevious); err != nil {
return err
}
// Comment
if err := g.SetKeybinding(showBugView, 'c', gocui.ModNone,
sb.comment); err != nil {
return err
}
// Title
if err := g.SetKeybinding(showBugView, 't', gocui.ModNone,
sb.setTitle); err != nil {
return err
}
// Labels
2018-08-01 03:15:40 +03:00
return nil
}
func (sb *showBug) disable(g *gocui.Gui) error {
for _, view := range sb.childViews {
if err := g.DeleteView(view); err != nil {
return err
}
2018-08-01 03:15:40 +03:00
}
return nil
}
func (sb *showBug) renderMain(g *gocui.Gui, mainView *gocui.View) error {
maxX, _ := mainView.Size()
x0, y0, _, _, _ := g.ViewPosition(mainView.Name())
y0 -= sb.scroll
snap := sb.bug.Snapshot()
2018-08-01 03:15:40 +03:00
sb.childViews = nil
sb.selectableView = nil
2018-08-09 15:51:19 +03:00
bugHeader := fmt.Sprintf("[ %s ] %s\n\n[ %s ] %s opened this bug on %s",
2018-08-09 15:36:23 +03:00
util.Cyan(snap.HumanId()),
util.Bold(snap.Title),
util.Yellow(snap.Status),
util.Magenta(snap.Author.Name),
snap.CreatedAt.Format(timeLayout),
)
2018-08-09 15:51:19 +03:00
bugHeader, lines := util.TextWrap(bugHeader, maxX)
2018-08-09 15:36:23 +03:00
v, err := sb.createOpView(g, showBugHeaderView, x0, y0, maxX+1, lines, false)
if err != nil {
2018-08-09 15:36:23 +03:00
return err
}
2018-08-09 15:51:19 +03:00
fmt.Fprint(v, bugHeader)
2018-08-09 15:36:23 +03:00
y0 += lines + 1
for i, op := range snap.Operations {
viewName := fmt.Sprintf("op%d", i)
2018-08-01 03:15:40 +03:00
// TODO: me might skip the rendering of blocks that are outside of the view
// but to do that we need to rework how sb.selectableView is maintained
2018-08-01 03:15:40 +03:00
switch op.(type) {
case operations.CreateOperation:
create := op.(operations.CreateOperation)
2018-08-09 15:51:19 +03:00
content, lines := util.TextWrapPadded(create.Message, maxX, 4)
2018-08-08 23:22:35 +03:00
v, err := sb.createOpView(g, viewName, x0, y0, maxX+1, lines, true)
if err != nil {
return err
}
fmt.Fprint(v, content)
y0 += lines + 2
2018-08-01 03:15:40 +03:00
case operations.AddCommentOperation:
comment := op.(operations.AddCommentOperation)
2018-08-09 15:51:19 +03:00
message, _ := util.TextWrapPadded(comment.Message, maxX, 4)
2018-08-09 15:36:23 +03:00
content := fmt.Sprintf("%s commented on %s\n\n%s",
util.Magenta(comment.Author.Name),
comment.Time().Format(timeLayout),
2018-08-09 15:51:19 +03:00
message,
2018-08-09 15:36:23 +03:00
)
2018-08-09 15:51:19 +03:00
content, lines = util.TextWrap(content, maxX)
2018-08-09 15:36:23 +03:00
v, err := sb.createOpView(g, viewName, x0, y0, maxX+1, lines, true)
if err != nil {
return err
}
fmt.Fprint(v, content)
y0 += lines + 2
2018-08-09 15:36:23 +03:00
case operations.SetTitleOperation:
setTitle := op.(operations.SetTitleOperation)
content := fmt.Sprintf("%s changed the title to %s on %s",
util.Magenta(setTitle.Author.Name),
util.Bold(setTitle.Title),
setTitle.Time().Format(timeLayout),
)
content, lines := util.TextWrap(content, maxX)
v, err := sb.createOpView(g, viewName, x0, y0, maxX+1, lines, true)
if err != nil {
return err
}
2018-08-09 15:36:23 +03:00
fmt.Fprint(v, content)
y0 += lines + 2
2018-08-01 03:15:40 +03:00
}
}
return nil
}
2018-08-08 23:22:35 +03:00
func (sb *showBug) createOpView(g *gocui.Gui, name string, x0 int, y0 int, maxX int, height int, selectable bool) (*gocui.View, error) {
v, err := g.SetView(name, x0, y0, maxX, y0+height+1)
if err != nil && err != gocui.ErrUnknownView {
return nil, err
}
sb.childViews = append(sb.childViews, name)
2018-08-08 23:22:35 +03:00
if selectable {
sb.selectableView = append(sb.selectableView, name)
}
2018-08-08 23:22:35 +03:00
v.Frame = sb.selected == name
v.Clear()
return v, nil
2018-08-01 03:15:40 +03:00
}
func (sb *showBug) renderSidebar(v *gocui.View) {
maxX, _ := v.Size()
snap := sb.bug.Snapshot()
2018-08-01 03:15:40 +03:00
title := util.LeftPaddedString("LABEL", maxX, 2)
fmt.Fprintf(v, title+"\n\n")
for _, label := range snap.Labels {
2018-08-01 03:15:40 +03:00
fmt.Fprintf(v, util.LeftPaddedString(label.String(), maxX, 2))
fmt.Fprintln(v)
}
}
func (sb *showBug) saveAndBack(g *gocui.Gui, v *gocui.View) error {
err := sb.bug.CommitAsNeeded()
if err != nil {
return err
}
2018-08-01 03:15:40 +03:00
ui.activateWindow(ui.bugTable)
return nil
}
func (sb *showBug) scrollUp(g *gocui.Gui, v *gocui.View) error {
mainView, err := g.View(showBugView)
if err != nil {
return err
}
_, maxY := mainView.Size()
sb.scroll -= maxY / 2
sb.scroll = maxInt(sb.scroll, 0)
2018-08-01 03:15:40 +03:00
return nil
}
func (sb *showBug) scrollDown(g *gocui.Gui, v *gocui.View) error {
_, maxY := v.Size()
lastViewName := sb.childViews[len(sb.childViews)-1]
lastView, err := g.View(lastViewName)
if err != nil {
return err
}
_, vMaxY := lastView.Size()
_, vy0, _, _, err := g.ViewPosition(lastViewName)
if err != nil {
return err
}
maxScroll := vy0 + sb.scroll + vMaxY - maxY
sb.scroll += maxY / 2
sb.scroll = minInt(sb.scroll, maxScroll)
2018-08-01 03:15:40 +03:00
return nil
}
2018-08-08 23:22:35 +03:00
func (sb *showBug) selectPrevious(g *gocui.Gui, v *gocui.View) error {
if len(sb.selectableView) == 0 {
return nil
}
defer sb.focusView(g)
2018-08-08 23:22:35 +03:00
for i, name := range sb.selectableView {
if name == sb.selected {
// special case to scroll up to the top
if i == 0 {
sb.scroll = 0
}
2018-08-08 23:22:35 +03:00
sb.selected = sb.selectableView[maxInt(i-1, 0)]
return nil
}
}
if sb.selected == "" {
sb.selected = sb.selectableView[0]
}
return nil
}
func (sb *showBug) selectNext(g *gocui.Gui, v *gocui.View) error {
if len(sb.selectableView) == 0 {
return nil
}
defer sb.focusView(g)
2018-08-08 23:22:35 +03:00
for i, name := range sb.selectableView {
if name == sb.selected {
sb.selected = sb.selectableView[minInt(i+1, len(sb.selectableView)-1)]
2018-08-08 23:22:35 +03:00
return nil
}
}
if sb.selected == "" {
sb.selected = sb.selectableView[0]
}
return nil
}
func (sb *showBug) focusView(g *gocui.Gui) error {
mainView, err := g.View(showBugView)
if err != nil {
return err
}
_, maxY := mainView.Size()
_, vy0, _, _, err := g.ViewPosition(sb.selected)
if err != nil {
return err
}
v, err := g.View(sb.selected)
if err != nil {
return err
}
_, vMaxY := v.Size()
vy1 := vy0 + vMaxY
if vy0 < 0 {
sb.scroll += vy0
return nil
}
if vy1 > maxY {
sb.scroll -= maxY - vy1
}
return nil
}
func (sb *showBug) comment(g *gocui.Gui, v *gocui.View) error {
return addCommentWithEditor(sb.bug)
}
func (sb *showBug) setTitle(g *gocui.Gui, v *gocui.View) error {
return setTitleWithEditor(sb.bug)
}