1package repo
  2
  3import (
  4	"fmt"
  5	"strings"
  6	"time"
  7
  8	"github.com/charmbracelet/bubbles/key"
  9	"github.com/charmbracelet/bubbles/spinner"
 10	tea "github.com/charmbracelet/bubbletea"
 11	gansi "github.com/charmbracelet/glamour/ansi"
 12	"github.com/charmbracelet/lipgloss"
 13	ggit "github.com/charmbracelet/soft-serve/git"
 14	"github.com/charmbracelet/soft-serve/ui/common"
 15	"github.com/charmbracelet/soft-serve/ui/components/selector"
 16	"github.com/charmbracelet/soft-serve/ui/components/viewport"
 17	"github.com/charmbracelet/soft-serve/ui/git"
 18	"github.com/muesli/reflow/wrap"
 19	"github.com/muesli/termenv"
 20)
 21
 22var (
 23	waitBeforeLoading = time.Millisecond * 200
 24)
 25
 26type logView int
 27
 28const (
 29	logViewCommits logView = iota
 30	logViewDiff
 31)
 32
 33// LogCountMsg is a message that contains the number of commits in a repo.
 34type LogCountMsg int64
 35
 36// LogItemsMsg is a message that contains a slice of LogItem.
 37type LogItemsMsg []selector.IdentifiableItem
 38
 39// LogCommitMsg is a message that contains a git commit.
 40type LogCommitMsg *ggit.Commit
 41
 42// LogDiffMsg is a message that contains a git diff.
 43type LogDiffMsg *ggit.Diff
 44
 45// Log is a model that displays a list of commits and their diffs.
 46type Log struct {
 47	common         common.Common
 48	selector       *selector.Selector
 49	vp             *viewport.Viewport
 50	activeView     logView
 51	repo           git.GitRepo
 52	ref            *ggit.Reference
 53	count          int64
 54	nextPage       int
 55	activeCommit   *ggit.Commit
 56	selectedCommit *ggit.Commit
 57	currentDiff    *ggit.Diff
 58	loadingTime    time.Time
 59	loading        bool
 60	spinner        spinner.Model
 61}
 62
 63// NewLog creates a new Log model.
 64func NewLog(common common.Common) *Log {
 65	l := &Log{
 66		common:     common,
 67		vp:         viewport.New(common),
 68		activeView: logViewCommits,
 69	}
 70	selector := selector.New(common, []selector.IdentifiableItem{}, LogItemDelegate{&common})
 71	selector.SetShowFilter(false)
 72	selector.SetShowHelp(false)
 73	selector.SetShowPagination(false)
 74	selector.SetShowStatusBar(false)
 75	selector.SetShowTitle(false)
 76	selector.SetFilteringEnabled(false)
 77	selector.DisableQuitKeybindings()
 78	selector.KeyMap.NextPage = common.KeyMap.NextPage
 79	selector.KeyMap.PrevPage = common.KeyMap.PrevPage
 80	l.selector = selector
 81	s := spinner.New()
 82	s.Spinner = spinner.Dot
 83	s.Style = common.Styles.Spinner
 84	l.spinner = s
 85	return l
 86}
 87
 88// SetSize implements common.Component.
 89func (l *Log) SetSize(width, height int) {
 90	l.common.SetSize(width, height)
 91	l.selector.SetSize(width, height)
 92	l.vp.SetSize(width, height)
 93}
 94
 95// ShortHelp implements help.KeyMap.
 96func (l *Log) ShortHelp() []key.Binding {
 97	switch l.activeView {
 98	case logViewCommits:
 99		copyKey := l.common.KeyMap.Copy
100		copyKey.SetHelp("c", "copy hash")
101		return []key.Binding{
102			l.common.KeyMap.UpDown,
103			l.common.KeyMap.SelectItem,
104			copyKey,
105		}
106	case logViewDiff:
107		return []key.Binding{
108			l.common.KeyMap.UpDown,
109			l.common.KeyMap.BackItem,
110		}
111	default:
112		return []key.Binding{}
113	}
114}
115
116// FullHelp implements help.KeyMap.
117func (l *Log) FullHelp() [][]key.Binding {
118	k := l.selector.KeyMap
119	b := make([][]key.Binding, 0)
120	switch l.activeView {
121	case logViewCommits:
122		copyKey := l.common.KeyMap.Copy
123		copyKey.SetHelp("c", "copy hash")
124		b = append(b, []key.Binding{
125			l.common.KeyMap.SelectItem,
126			l.common.KeyMap.BackItem,
127		})
128		b = append(b, [][]key.Binding{
129			{
130				copyKey,
131				k.CursorUp,
132				k.CursorDown,
133			},
134			{
135				k.NextPage,
136				k.PrevPage,
137				k.GoToStart,
138				k.GoToEnd,
139			},
140		}...)
141	case logViewDiff:
142		k := l.vp.KeyMap
143		b = append(b, []key.Binding{
144			l.common.KeyMap.BackItem,
145		})
146		b = append(b, [][]key.Binding{
147			{
148				k.PageDown,
149				k.PageUp,
150				k.HalfPageDown,
151				k.HalfPageUp,
152			},
153			{
154				k.Down,
155				k.Up,
156			},
157		}...)
158	}
159	return b
160}
161
162func (l *Log) startLoading() tea.Msg {
163	l.loadingTime = time.Now()
164	l.loading = true
165	return l.spinner.Tick()
166}
167
168func (l *Log) stopLoading() {
169	l.loading = false
170}
171
172// Init implements tea.Model.
173func (l *Log) Init() tea.Cmd {
174	l.activeView = logViewCommits
175	l.nextPage = 0
176	l.count = 0
177	l.activeCommit = nil
178	l.selector.Select(0)
179	return tea.Batch(
180		l.updateCommitsCmd,
181		// start loading on init
182		l.startLoading,
183	)
184}
185
186// Update implements tea.Model.
187func (l *Log) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
188	cmds := make([]tea.Cmd, 0)
189	switch msg := msg.(type) {
190	case RepoMsg:
191		l.repo = git.GitRepo(msg)
192		cmds = append(cmds, l.Init())
193	case RefMsg:
194		l.ref = msg
195		cmds = append(cmds, l.Init())
196	case LogCountMsg:
197		l.count = int64(msg)
198	case LogItemsMsg:
199		cmds = append(cmds, l.selector.SetItems(msg))
200		l.selector.SetPage(l.nextPage)
201		l.SetSize(l.common.Width, l.common.Height)
202		i := l.selector.SelectedItem()
203		if i != nil {
204			l.activeCommit = i.(LogItem).Commit
205		}
206		// stop loading after receiving items
207		l.stopLoading()
208	case tea.KeyMsg, tea.MouseMsg:
209		switch l.activeView {
210		case logViewCommits:
211			switch key := msg.(type) {
212			case tea.KeyMsg:
213				switch key.String() {
214				case "l", "right":
215					cmds = append(cmds, l.selector.SelectItem)
216				}
217			}
218			// This is a hack for loading commits on demand based on list.Pagination.
219			curPage := l.selector.Page()
220			s, cmd := l.selector.Update(msg)
221			m := s.(*selector.Selector)
222			l.selector = m
223			if m.Page() != curPage {
224				l.nextPage = m.Page()
225				l.selector.SetPage(curPage)
226				cmds = append(cmds,
227					l.updateCommitsCmd,
228					l.startLoading,
229				)
230			}
231			cmds = append(cmds, cmd)
232		case logViewDiff:
233			switch key := msg.(type) {
234			case tea.KeyMsg:
235				switch key.String() {
236				case "h", "left":
237					l.activeView = logViewCommits
238				}
239			}
240		}
241	case selector.ActiveMsg:
242		switch sel := msg.IdentifiableItem.(type) {
243		case LogItem:
244			l.activeCommit = sel.Commit
245		}
246		cmds = append(cmds, updateStatusBarCmd)
247	case selector.SelectMsg:
248		switch sel := msg.IdentifiableItem.(type) {
249		case LogItem:
250			cmds = append(cmds,
251				l.selectCommitCmd(sel.Commit),
252				l.startLoading,
253			)
254		}
255	case LogCommitMsg:
256		l.selectedCommit = msg
257		cmds = append(cmds, l.loadDiffCmd)
258	case LogDiffMsg:
259		l.currentDiff = msg
260		l.vp.SetContent(
261			lipgloss.JoinVertical(lipgloss.Top,
262				l.renderCommit(l.selectedCommit),
263				l.renderSummary(msg),
264				l.renderDiff(msg),
265			),
266		)
267		l.vp.GotoTop()
268		l.activeView = logViewDiff
269		cmds = append(cmds, updateStatusBarCmd)
270		// stop loading after setting the viewport content
271		l.stopLoading()
272	case tea.WindowSizeMsg:
273		if l.selectedCommit != nil && l.currentDiff != nil {
274			l.vp.SetContent(
275				lipgloss.JoinVertical(lipgloss.Top,
276					l.renderCommit(l.selectedCommit),
277					l.renderSummary(l.currentDiff),
278					l.renderDiff(l.currentDiff),
279				),
280			)
281		}
282		if l.repo != nil {
283			cmds = append(cmds,
284				l.updateCommitsCmd,
285				// start loading on resize since the number of commits per page
286				// might change and we'd need to load more commits.
287				l.startLoading,
288			)
289		}
290	}
291	if l.loading {
292		s, cmd := l.spinner.Update(msg)
293		if cmd != nil {
294			cmds = append(cmds, cmd)
295		}
296		l.spinner = s
297	}
298	switch l.activeView {
299	case logViewDiff:
300		vp, cmd := l.vp.Update(msg)
301		l.vp = vp.(*viewport.Viewport)
302		if cmd != nil {
303			cmds = append(cmds, cmd)
304		}
305	}
306	return l, tea.Batch(cmds...)
307}
308
309// View implements tea.Model.
310func (l *Log) View() string {
311	if l.loading && l.loadingTime.Add(waitBeforeLoading).Before(time.Now()) {
312		msg := fmt.Sprintf("%s loading commit", l.spinner.View())
313		if l.selectedCommit == nil {
314			msg += "s"
315		}
316		msg += "…"
317		return msg
318	}
319	switch l.activeView {
320	case logViewCommits:
321		return l.selector.View()
322	case logViewDiff:
323		return l.vp.View()
324	default:
325		return ""
326	}
327}
328
329// StatusBarValue returns the status bar value.
330func (l *Log) StatusBarValue() string {
331	c := l.activeCommit
332	if c == nil {
333		return ""
334	}
335	who := c.Author.Name
336	if email := c.Author.Email; email != "" {
337		who += " <" + email + ">"
338	}
339	value := c.ID.String()
340	if who != "" {
341		value += " by " + who
342	}
343	return value
344}
345
346// StatusBarInfo returns the status bar info.
347func (l *Log) StatusBarInfo() string {
348	switch l.activeView {
349	case logViewCommits:
350		// We're using l.nextPage instead of l.selector.Paginator.Page because
351		// of the paginator hack above.
352		return fmt.Sprintf("p. %d/%d", l.nextPage+1, l.selector.TotalPages())
353	case logViewDiff:
354		return fmt.Sprintf("☰ %.f%%", l.vp.ScrollPercent()*100)
355	default:
356		return ""
357	}
358}
359
360func (l *Log) countCommitsCmd() tea.Msg {
361	if l.ref == nil {
362		return common.ErrorMsg(errNoRef)
363	}
364	count, err := l.repo.CountCommits(l.ref)
365	if err != nil {
366		return common.ErrorMsg(err)
367	}
368	return LogCountMsg(count)
369}
370
371func (l *Log) updateCommitsCmd() tea.Msg {
372	count := l.count
373	if l.count == 0 {
374		switch msg := l.countCommitsCmd().(type) {
375		case common.ErrorMsg:
376			return msg
377		case LogCountMsg:
378			count = int64(msg)
379		}
380	}
381	if l.ref == nil {
382		return common.ErrorMsg(errNoRef)
383	}
384	items := make([]selector.IdentifiableItem, count)
385	page := l.nextPage
386	limit := l.selector.PerPage()
387	skip := page * limit
388	// CommitsByPage pages start at 1
389	cc, err := l.repo.CommitsByPage(l.ref, page+1, limit)
390	if err != nil {
391		return common.ErrorMsg(err)
392	}
393	for i, c := range cc {
394		idx := i + skip
395		if int64(idx) >= count {
396			break
397		}
398		items[idx] = LogItem{Commit: c}
399	}
400	return LogItemsMsg(items)
401}
402
403func (l *Log) selectCommitCmd(commit *ggit.Commit) tea.Cmd {
404	return func() tea.Msg {
405		return LogCommitMsg(commit)
406	}
407}
408
409func (l *Log) loadDiffCmd() tea.Msg {
410	diff, err := l.repo.Diff(l.selectedCommit)
411	if err != nil {
412		return common.ErrorMsg(err)
413	}
414	return LogDiffMsg(diff)
415}
416
417func renderCtx() gansi.RenderContext {
418	return gansi.NewRenderContext(gansi.Options{
419		ColorProfile: termenv.TrueColor,
420		Styles:       common.StyleConfig(),
421	})
422}
423
424func (l *Log) renderCommit(c *ggit.Commit) string {
425	s := strings.Builder{}
426	// FIXME: lipgloss prints empty lines when CRLF is used
427	// sanitize commit message from CRLF
428	msg := strings.ReplaceAll(c.Message, "\r\n", "\n")
429	s.WriteString(fmt.Sprintf("%s\n%s\n%s\n%s\n",
430		l.common.Styles.LogCommitHash.Render("commit "+c.ID.String()),
431		l.common.Styles.LogCommitAuthor.Render(fmt.Sprintf("Author: %s <%s>", c.Author.Name, c.Author.Email)),
432		l.common.Styles.LogCommitDate.Render("Date:   "+c.Committer.When.Format(time.UnixDate)),
433		l.common.Styles.LogCommitBody.Render(msg),
434	))
435	return wrap.String(s.String(), l.common.Width-2)
436}
437
438func (l *Log) renderSummary(diff *ggit.Diff) string {
439	stats := strings.Split(diff.Stats().String(), "\n")
440	for i, line := range stats {
441		ch := strings.Split(line, "|")
442		if len(ch) > 1 {
443			adddel := ch[len(ch)-1]
444			adddel = strings.ReplaceAll(adddel, "+", l.common.Styles.LogCommitStatsAdd.Render("+"))
445			adddel = strings.ReplaceAll(adddel, "-", l.common.Styles.LogCommitStatsDel.Render("-"))
446			stats[i] = strings.Join(ch[:len(ch)-1], "|") + "|" + adddel
447		}
448	}
449	return wrap.String(strings.Join(stats, "\n"), l.common.Width-2)
450}
451
452func (l *Log) renderDiff(diff *ggit.Diff) string {
453	var s strings.Builder
454	var pr strings.Builder
455	diffChroma := &gansi.CodeBlockElement{
456		Code:     diff.Patch(),
457		Language: "diff",
458	}
459	err := diffChroma.Render(&pr, renderCtx())
460	if err != nil {
461		s.WriteString(fmt.Sprintf("\n%s", err.Error()))
462	} else {
463		s.WriteString(fmt.Sprintf("\n%s", pr.String()))
464	}
465	return wrap.String(s.String(), l.common.Width-2)
466}