implement status with help

Author: samtholiya

pkg/pager/err.go

@@ -0,0 +1,5 @@
+package pager
+
+type errMsg struct{ err error }
+
+func (e errMsg) Error() string { return e.err.Error() }

pkg/pager/model.go

@@ -2,13 +2,100 @@ package pager
 
 import (
 	"fmt"
+	"math"
+	"regexp"
 	"strings"
+	"time"
 
+	"github.com/atotto/clipboard"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
+	"github.com/mattn/go-runewidth"
+	"github.com/muesli/ansi"
+	"github.com/muesli/reflow/truncate"
+	"github.com/muesli/termenv"
 )
 
+const (
+	minPercent               float64 = 0.0
+	maxPercent               float64 = 1.0
+	percentToStringMagnitude float64 = 100.0
+
+	statusMessageTimeout = time.Second * 3 // how long to show status messages like "stashed!"
+	ellipsis             = "…"
+	statusBarHeight      = 1
+)
+
+type pagerState int
+
+const (
+	pagerStateBrowse pagerState = iota
+	pagerStateStatusMessage
+)
+
+type pagerStatusMessage struct {
+	message string
+	isError bool
+}
+
+var (
+	pagerHelpHeight int
+
+	// Logo
+	logo = statusBarHelpStyle(" \U0001F47D  ")
+
+	mintGreen = lipgloss.AdaptiveColor{Light: "#89F0CB", Dark: "#89F0CB"}
+	darkGreen = lipgloss.AdaptiveColor{Light: "#1C8760", Dark: "#1C8760"}
+
+	lineNumberFg = lipgloss.AdaptiveColor{Light: "#656565", Dark: "#7D7D7D"}
+
+	statusBarNoteFg = lipgloss.AdaptiveColor{Light: "#656565", Dark: "#7D7D7D"}
+	statusBarBg     = lipgloss.AdaptiveColor{Light: "#E6E6E6", Dark: "#242424"}
+
+	statusBarNoteStyle = lipgloss.NewStyle().
+				Foreground(statusBarNoteFg).
+				Background(statusBarBg).
+				Render
+
+	statusBarHelpStyle = lipgloss.NewStyle().
+				Foreground(statusBarNoteFg).
+				Background(lipgloss.AdaptiveColor{Light: "#DCDCDC", Dark: "#323232"}).
+				Render
+
+	statusBarMessageStyle = lipgloss.NewStyle().
+				Foreground(mintGreen).
+				Background(darkGreen).
+				Render
+
+	statusBarMessageScrollPosStyle = lipgloss.NewStyle().
+					Foreground(mintGreen).
+					Background(darkGreen).
+					Render
+
+	statusBarMessageHelpStyle = lipgloss.NewStyle().
+					Foreground(lipgloss.Color("#B6FFE4")).
+					Background(green).
+					Render
+
+	helpViewStyle = lipgloss.NewStyle().
+			Foreground(statusBarNoteFg).
+			Background(lipgloss.AdaptiveColor{Light: "#f2f2f2", Dark: "#1B1B1B"}).
+			Render
+
+	lineNumberStyle = lipgloss.NewStyle().
+			Foreground(lineNumberFg).
+			Render
+	green = lipgloss.Color("#04B575")
+)
+
+// Common stuff we'll need to access in all models.
+type commonModel struct {
+	cwd    string
+	width  int
+	height int
+}
+
 var (
 	titleStyle = func() lipgloss.Style {
 		b := lipgloss.RoundedBorder()
@@ -28,12 +115,25 @@ type model struct {
 	content  string
 	ready    bool
 	viewport viewport.Model
+	common   commonModel
+	showHelp bool
+
+	state              pagerState
+	statusMessage      string
+	statusMessageTimer *time.Timer
 }
 
 func (m *model) Init() tea.Cmd {
 	return nil
 }
 
+var ansiRegex = regexp.MustCompile(`\x1b\[[0-9;?]*[ -/]*[@-~]`)
+
+// StripANSI removes ANSI escape sequences (like terminal colors) from input.
+func StripANSI(input string) string {
+	return ansiRegex.ReplaceAllString(input, "")
+}
+
 func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var (
 		cmd  tea.Cmd
@@ -42,14 +142,33 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
-		if k := msg.String(); k == "ctrl+c" || k == "q" || k == "esc" {
+		switch msg.String() {
+		case "q", "esc", "ctrl+c":
 			return m, tea.Quit
+		case "home", "g":
+			m.viewport.GotoTop()
+		case "end", "G":
+			m.viewport.GotoBottom()
+		case "c":
+			// Copy using OSC 52
+			termenv.Copy(StripANSI(m.content))
+			// Copy using native system clipboard
+			_ = clipboard.WriteAll(StripANSI(m.content))
+			cmds = append(cmds, m.showStatusMessage(pagerStatusMessage{"Copied contents", false}))
+
+		case "?":
+			m.toggleHelp()
 		}
 
+	case statusMessageTimeoutMsg:
+		m.state = pagerStateBrowse
+		// Window size is received when starting up and on every resize
 	case tea.WindowSizeMsg:
-		headerHeight := lipgloss.Height(m.headerView())
+		m.common.width = msg.Width
+		m.common.height = msg.Height
+
 		footerHeight := lipgloss.Height(m.footerView())
-		verticalMarginHeight := headerHeight + footerHeight
+		verticalMarginHeight := footerHeight
 
 		if !m.ready {
 			// Since this program is using the full size of the viewport we
@@ -58,7 +177,7 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			// quickly, though asynchronously, which is why we wait for them
 			// here.
 			m.viewport = viewport.New(msg.Width, msg.Height-verticalMarginHeight)
-			m.viewport.YPosition = headerHeight
+			m.viewport.YPosition = 0
 			m.viewport.SetContent(m.content)
 			m.ready = true
 		} else {
@@ -74,23 +193,104 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
+type statusMessageTimeoutMsg applicationContext
+
+// applicationContext indicates the area of the application something applies
+// to. Occasionally used as an argument to commands and messages.
+type applicationContext int
+
+const (
+	stashContext applicationContext = iota
+	pagerContext
+)
+
+// Perform stuff that needs to happen after a successful markdown stash. Note
+// that the the returned command should be sent back the through the pager
+// update function.
+func (m *model) showStatusMessage(msg pagerStatusMessage) tea.Cmd {
+	// Show a success message to the user
+	m.state = pagerStateStatusMessage
+	m.statusMessage = msg.message
+	if m.statusMessageTimer != nil {
+		m.statusMessageTimer.Stop()
+	}
+	m.statusMessageTimer = time.NewTimer(statusMessageTimeout)
+
+	return waitForStatusMessageTimeout(pagerContext, m.statusMessageTimer)
+}
+
+func waitForStatusMessageTimeout(appCtx applicationContext, t *time.Timer) tea.Cmd {
+	return func() tea.Msg {
+		<-t.C
+		return statusMessageTimeoutMsg(appCtx)
+	}
+}
+
+func (m *model) toggleHelp() {
+	m.showHelp = !m.showHelp
+	m.setSize(m.common.width, m.common.height)
+	if m.viewport.PastBottom() {
+		m.viewport.GotoBottom()
+	}
+}
+
+func (m *model) setSize(w, h int) {
+	m.viewport.Width = w
+	m.viewport.Height = h - statusBarHeight
+
+	if m.showHelp {
+		if pagerHelpHeight == 0 {
+			pagerHelpHeight = strings.Count(m.helpView(), "\n")
+		}
+		m.viewport.Height -= (statusBarHeight + pagerHelpHeight)
+	}
+}
+
 func (m *model) View() string {
 	if !m.ready {
 		return "\n  Initializing..."
 	}
-	return fmt.Sprintf("%s\n%s\n%s", m.headerView(), m.viewport.View(), m.footerView())
+	return fmt.Sprintf("%s\n%s", m.viewport.View(), m.footerView())
 }
 
-func (m *model) headerView() string {
-	title := titleStyle.Render(m.title)
-	line := strings.Repeat("─", max(0, m.viewport.Width-lipgloss.Width(title)))
-	return lipgloss.JoinHorizontal(lipgloss.Center, title, line)
+func (m model) helpView() (s string) {
+	col1 := []string{
+		"g/home  go to top",
+		"G/end   go to bottom",
+		"c       copy contents",
+		"esc     back to files",
+		"q       quit",
+	}
+
+	s += "\n"
+	s += "k/↑      up                  " + col1[0] + "\n"
+	s += "j/↓      down                " + col1[1] + "\n"
+	s += "b/pgup   page up             " + col1[2] + "\n"
+	s += "f/pgdn   page down           " + col1[3] + "\n"
+	s += "u        ½ page up           " + col1[4] + "\n"
+	s += "d        ½ page down         "
+
+	s = indent(s, 2)
+
+	// Fill up empty cells with spaces for background coloring
+	if m.common.width > 0 {
+		lines := strings.Split(s, "\n")
+		for i := 0; i < len(lines); i++ {
+			l := runewidth.StringWidth(lines[i])
+			n := max(m.common.width-l, 0)
+			lines[i] += strings.Repeat(" ", n)
+		}
+
+		s = strings.Join(lines, "\n")
+	}
+
+	return helpViewStyle(s)
 }
 
 func (m *model) footerView() string {
-	info := infoStyle.Render(fmt.Sprintf("%3.f%%", m.viewport.ScrollPercent()*100))
-	line := strings.Repeat("─", max(0, m.viewport.Width-lipgloss.Width(info)))
-	return lipgloss.JoinHorizontal(lipgloss.Center, line, info)
+	b := &strings.Builder{}
+	m.statusBarView(b)
+	return b.String()
 }
 
 func max(a, b int) int {
@@ -99,3 +299,84 @@ func max(a, b int) int {
 	}
 	return b
 }
+
+func (m model) statusBarView(b *strings.Builder) {
+
+	showStatusMessage := m.state == pagerStateStatusMessage
+
+	// Scroll percent
+	percent := math.Max(minPercent, math.Min(maxPercent, m.viewport.ScrollPercent()))
+	scrollPercent := fmt.Sprintf(" %3.f%% ", percent*percentToStringMagnitude)
+	if showStatusMessage {
+		scrollPercent = statusBarMessageScrollPosStyle(scrollPercent)
+	} else {
+		scrollPercent = statusBarNoteStyle(scrollPercent)
+	}
+
+	// Note
+	var note string
+	if showStatusMessage {
+		note = m.statusMessage
+	} else {
+		note = m.title
+	}
+	note = truncate.StringWithTail(" "+note+" ", uint(max(0, //nolint:gosec
+		m.common.width-
+			ansi.PrintableRuneWidth(logo)-
+			ansi.PrintableRuneWidth(scrollPercent),
+	)), ellipsis)
+
+	if showStatusMessage {
+		note = statusBarMessageStyle(note)
+	} else {
+		note = statusBarNoteStyle(note)
+	}
+
+	// "Help" note
+	var helpNote string
+	if showStatusMessage {
+		helpNote = statusBarMessageHelpStyle(" ? Help ")
+	} else {
+		helpNote = statusBarHelpStyle(" ? Help ")
+	}
+
+	// Empty space
+	padding := max(0,
+		m.common.width-
+			ansi.PrintableRuneWidth(logo)-
+			ansi.PrintableRuneWidth(note)-
+			ansi.PrintableRuneWidth(scrollPercent)-
+			ansi.PrintableRuneWidth(helpNote),
+	)
+	emptySpace := strings.Repeat(" ", padding)
+	if showStatusMessage {
+		emptySpace = statusBarMessageStyle(emptySpace)
+	} else {
+		emptySpace = statusBarNoteStyle(emptySpace)
+	}
+
+	fmt.Fprintf(b, "%s%s%s%s%s",
+		logo,
+		note,
+		emptySpace,
+		scrollPercent,
+		helpNote,
+	)
+	if m.showHelp {
+		fmt.Fprint(b, "\n"+m.helpView())
+	}
+}
+
+// Lightweight version of reflow's indent function.?
+func indent(s string, n int) string {
+	if n <= 0 || s == "" {
+		return s
+	}
+	l := strings.Split(s, "\n")
+	b := strings.Builder{}
+	i := strings.Repeat(" ", n)
+	for _, v := range l {
+		fmt.Fprintf(&b, "%s%s\n", i, v)
+	}
+	return b.String()
+}

pkg/pager/model_test.go

@@ -104,21 +104,6 @@ func TestModel_View(t *testing.T) {
 	})
 }
 
-func TestModel_headerView(t *testing.T) {
-	t.Run("NormalWidth", func(t *testing.T) {
-		m := model{
-			title:    "Test",
-			viewport: viewport.New(20, 10),
-		}
-		header := m.headerView()
-
-		expectedTitle := titleStyle.Render("Test")
-		lineLength := 20 - lipgloss.Width(expectedTitle)
-		assert.Contains(t, header, "Test", "Header should contain title")
-		assert.Contains(t, header, strings.Repeat("─", lineLength), "Header should contain line")
-	})
-}
-
 func TestModel_footerView(t *testing.T) {
 	t.Run("NormalWidth", func(t *testing.T) {
 		vp := viewport.New(20, 10)