glow/ui/stash.go

891 lines
21 KiB
Go
Raw Normal View History

package ui
import (
"errors"
2020-05-13 23:02:39 +00:00
"fmt"
2022-10-25 14:40:51 +00:00
"os"
2020-05-13 23:02:39 +00:00
"sort"
"strings"
2020-05-19 00:45:13 +00:00
"time"
2020-05-13 23:02:39 +00:00
"github.com/charmbracelet/bubbles/paginator"
"github.com/charmbracelet/bubbles/spinner"
"github.com/charmbracelet/bubbles/textinput"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/charmbracelet/log"
"github.com/muesli/reflow/ansi"
"github.com/muesli/reflow/truncate"
"github.com/sahilm/fuzzy"
)
2020-05-15 00:23:11 +00:00
const (
stashIndent = 1
2020-11-30 23:44:58 +00:00
stashViewItemHeight = 3 // height of stash entry, including gap
stashViewTopPadding = 5 // logo, status bar, gaps
stashViewBottomPadding = 3 // pagination and gaps, but not help
2020-05-22 02:29:46 +00:00
stashViewHorizontalPadding = 6
)
var stashingStatusMessage = statusMessage{normalStatusMessage, "Stashing..."}
2020-05-15 00:23:11 +00:00
var (
dividerDot = darkGrayFg.SetString(" • ")
dividerBar = darkGrayFg.SetString(" │ ")
logoStyle = lipgloss.NewStyle().
Foreground(lipgloss.Color("#ECFD65")).
Background(fuchsia).
Bold(true)
stashSpinnerStyle = lipgloss.NewStyle().
Foreground(gray)
stashInputPromptStyle = lipgloss.NewStyle().
Foreground(yellowGreen).
MarginRight(1)
stashInputCursorStyle = lipgloss.NewStyle().
Foreground(fuchsia).
MarginRight(1)
)
// MSG
2022-10-25 14:40:51 +00:00
type (
filteredMarkdownMsg []*markdown
fetchedMarkdownMsg *markdown
2022-10-25 14:40:51 +00:00
)
2020-12-10 01:12:01 +00:00
// MODEL
2020-12-11 03:53:09 +00:00
// stashViewState is the high-level state of the file listing.
type stashViewState int
const (
stashStateReady stashViewState = iota
2020-05-15 19:08:45 +00:00
stashStateLoadingDocument
stashStateShowingError
)
// The types of documents we are currently showing to the user.
type sectionKey int
const (
documentsSection = iota
2020-12-15 18:37:11 +00:00
filterSection
)
2020-12-11 03:53:09 +00:00
// section contains definitions and state information for displaying a tab and
// its contents in the file listing view.
type section struct {
key sectionKey
paginator paginator.Model
cursor int
}
2020-12-11 03:53:09 +00:00
// map sections to their associated types.
2023-05-05 09:40:36 +00:00
var sections = map[sectionKey]section{}
2020-12-11 03:53:09 +00:00
// filterState is the current filtering state in the file listing.
type filterState int
const (
unfiltered filterState = iota // no filter set
filtering // user is actively setting a filter
filterApplied // a filter is applied and user is not editing filter
)
// statusMessageType adds some context to the status message being sent.
type statusMessageType int
// Types of status messages.
const (
normalStatusMessage statusMessageType = iota
subtleStatusMessage
errorStatusMessage
)
// statusMessage is an ephemeral note displayed in the UI.
type statusMessage struct {
status statusMessageType
message string
}
2023-05-05 09:40:36 +00:00
func initSections() {
sections = map[sectionKey]section{
documentsSection: {
key: documentsSection,
2023-05-05 09:40:36 +00:00
paginator: newStashPaginator(),
},
filterSection: {
key: filterSection,
paginator: newStashPaginator(),
},
}
}
// String returns a styled version of the status message appropriate for the
// given context.
func (s statusMessage) String() string {
switch s.status {
case subtleStatusMessage:
return dimGreenFg(s.message)
case errorStatusMessage:
return redFg(s.message)
default:
return greenFg(s.message)
}
}
type stashModel struct {
2020-12-18 19:28:21 +00:00
common *commonModel
err error
spinner spinner.Model
filterInput textinput.Model
stashFullyLoaded bool // have we loaded all available stashed documents from the server?
viewState stashViewState
filterState filterState
showFullHelp bool
showStatusMessage bool
statusMessage statusMessage
statusMessageTimer *time.Timer
// Available document sections we can cycle through. We use a slice, rather
// than a map, because order is important.
sections []section
// Index of the section we're currently looking at
sectionIndex int
// Tracks if docs were loaded
loaded bool
2020-05-15 00:23:11 +00:00
// The master set of markdown documents we're working with.
markdowns []*markdown
// Markdown documents we're currently displaying. Filtering, toggles and so
// on will alter this slice so we can show what is relevant. For that
// reason, this field should be considered ephemeral.
filteredMarkdowns []*markdown
2020-05-21 19:14:33 +00:00
// Page we're fetching stash items from on the server, which is different
// from the local pagination. Generally, the server will return more items
// than we can display at a time so we can paginate locally without having
// to fetch every time.
serverPage int64
}
2020-10-18 03:01:20 +00:00
func (m stashModel) loadingDone() bool {
return m.loaded
2020-10-18 03:01:20 +00:00
}
func (m stashModel) currentSection() *section {
return &m.sections[m.sectionIndex]
}
func (m stashModel) paginator() *paginator.Model {
return &m.currentSection().paginator
}
func (m *stashModel) setPaginator(p paginator.Model) {
m.currentSection().paginator = p
}
func (m stashModel) cursor() int {
return m.currentSection().cursor
}
func (m *stashModel) setCursor(i int) {
m.currentSection().cursor = i
}
// Whether or not the spinner should be spinning.
func (m stashModel) shouldSpin() bool {
loading := !m.loadingDone()
openingDocument := m.viewState == stashStateLoadingDocument
return loading || openingDocument
}
func (m *stashModel) setSize(width, height int) {
m.common.width = width
m.common.height = height
2020-05-15 00:23:11 +00:00
m.filterInput.Width = width - stashViewHorizontalPadding*2 - ansi.PrintableRuneWidth(
m.filterInput.Prompt,
)
m.updatePagination()
}
func (m *stashModel) resetFiltering() {
m.filterState = unfiltered
m.filterInput.Reset()
m.filteredMarkdowns = nil
sortMarkdowns(m.markdowns)
2020-12-15 18:37:11 +00:00
// If the filtered section is present (it's always at the end) slice it out
// of the sections slice to remove it from the UI.
2020-12-15 18:37:11 +00:00
if m.sections[len(m.sections)-1].key == filterSection {
m.sections = m.sections[:len(m.sections)-1]
}
// If the current section is out of bounds (it would be if we cut down the
// slice above) then return to the first section.
2020-12-15 18:37:11 +00:00
if m.sectionIndex > len(m.sections)-1 {
m.sectionIndex = 0
}
// Update pagination after we've switched sections.
m.updatePagination()
}
// Is a filter currently being applied?
2020-12-15 18:37:11 +00:00
func (m stashModel) filterApplied() bool {
return m.filterState != unfiltered
}
// Should we be updating the filter?
func (m stashModel) shouldUpdateFilter() bool {
// If we're in the middle of setting a note don't update the filter so that
// the focus won't jump around.
return m.filterApplied()
}
// Update pagination according to the amount of markdowns for the current
// state.
func (m *stashModel) updatePagination() {
_, helpHeight := m.helpView()
availableHeight := m.common.height -
stashViewTopPadding -
2020-11-30 23:44:58 +00:00
helpHeight -
stashViewBottomPadding
m.paginator().PerPage = max(1, availableHeight/stashViewItemHeight)
if pages := len(m.getVisibleMarkdowns()); pages < 1 {
m.paginator().SetTotalPages(1)
} else {
m.paginator().SetTotalPages(pages)
}
2020-05-22 02:29:46 +00:00
// Make sure the page stays in bounds
if m.paginator().Page >= m.paginator().TotalPages-1 {
m.paginator().Page = max(0, m.paginator().TotalPages-1)
}
}
// MarkdownIndex returns the index of the currently selected markdown item.
2020-05-21 19:14:33 +00:00
func (m stashModel) markdownIndex() int {
return m.paginator().Page*m.paginator().PerPage + m.cursor()
2020-05-21 19:14:33 +00:00
}
// Return the current selected markdown in the stash.
2020-05-22 20:28:15 +00:00
func (m stashModel) selectedMarkdown() *markdown {
i := m.markdownIndex()
2020-10-24 20:45:05 +00:00
mds := m.getVisibleMarkdowns()
if i < 0 || len(mds) == 0 || len(mds) <= i {
return nil
}
2020-10-24 20:45:05 +00:00
return mds[i]
2020-05-22 20:28:15 +00:00
}
// Adds markdown documents to the model.
2020-05-22 20:01:23 +00:00
func (m *stashModel) addMarkdowns(mds ...*markdown) {
if len(mds) == 0 {
return
}
m.markdowns = append(m.markdowns, mds...)
if !m.filterApplied() {
sortMarkdowns(m.markdowns)
}
2020-11-25 16:40:24 +00:00
m.updatePagination()
2020-11-25 16:40:24 +00:00
}
// Returns the markdowns that should be currently shown.
func (m stashModel) getVisibleMarkdowns() []*markdown {
2020-12-15 18:37:11 +00:00
if m.filterState == filtering || m.currentSection().key == filterSection {
return m.filteredMarkdowns
}
2020-11-25 16:40:24 +00:00
return m.markdowns
}
// Command for opening a markdown document in the pager. Note that this also
// alters the model.
func (m *stashModel) openMarkdown(md *markdown) tea.Cmd {
m.viewState = stashStateLoadingDocument
cmd := loadLocalMarkdown(md)
return tea.Batch(cmd, m.spinner.Tick)
}
2020-08-21 17:39:59 +00:00
func (m *stashModel) hideStatusMessage() {
m.showStatusMessage = false
m.statusMessage = statusMessage{}
2020-08-21 17:39:59 +00:00
if m.statusMessageTimer != nil {
m.statusMessageTimer.Stop()
}
}
func (m *stashModel) moveCursorUp() {
m.setCursor(m.cursor() - 1)
if m.cursor() < 0 && m.paginator().Page == 0 {
// Stop
m.setCursor(0)
return
}
if m.cursor() >= 0 {
return
}
// Go to previous page
m.paginator().PrevPage()
m.setCursor(m.paginator().ItemsOnPage(len(m.getVisibleMarkdowns())) - 1)
}
func (m *stashModel) moveCursorDown() {
itemsOnPage := m.paginator().ItemsOnPage(len(m.getVisibleMarkdowns()))
m.setCursor(m.cursor() + 1)
if m.cursor() < itemsOnPage {
return
}
if !m.paginator().OnLastPage() {
m.paginator().NextPage()
m.setCursor(0)
return
}
// During filtering the cursor position can exceed the number of
// itemsOnPage. It's more intuitive to start the cursor at the
// topmost position when moving it down in this scenario.
if m.cursor() > itemsOnPage {
m.setCursor(0)
return
}
m.setCursor(itemsOnPage - 1)
}
// INIT
func newStashModel(common *commonModel) stashModel {
sp := spinner.New()
sp.Spinner = spinner.Line
sp.Style = stashSpinnerStyle
si := textinput.New()
si.Prompt = "Find:"
si.PromptStyle = stashInputPromptStyle
si.Cursor.Style = stashInputCursorStyle
si.Focus()
s := []section{
sections[documentsSection],
}
m := stashModel{
common: common,
spinner: sp,
filterInput: si,
serverPage: 1,
sections: s,
}
return m
}
2020-12-15 18:37:11 +00:00
func newStashPaginator() paginator.Model {
p := paginator.New()
2020-12-15 18:37:11 +00:00
p.Type = paginator.Dots
p.ActiveDot = brightGrayFg("•")
2023-05-05 09:40:36 +00:00
p.InactiveDot = darkGrayFg.Render("•")
2020-12-15 18:37:11 +00:00
return p
}
// UPDATE
2020-11-25 16:40:24 +00:00
func (m stashModel) update(msg tea.Msg) (stashModel, tea.Cmd) {
var cmds []tea.Cmd
2020-05-15 00:52:25 +00:00
switch msg := msg.(type) {
case errMsg:
m.err = msg
case localFileSearchFinished:
// We're finished searching for local files
m.loaded = true
2020-12-10 01:12:01 +00:00
case filteredMarkdownMsg:
m.filteredMarkdowns = msg
m.setCursor(0)
return m, nil
case spinner.TickMsg:
if m.shouldSpin() {
var cmd tea.Cmd
m.spinner, cmd = m.spinner.Update(msg)
2020-05-15 22:39:23 +00:00
cmds = append(cmds, cmd)
}
2020-08-21 17:39:59 +00:00
case statusMessageTimeoutMsg:
if applicationContext(msg) == stashContext {
m.hideStatusMessage()
}
}
if m.filterState == filtering {
cmds = append(cmds, m.handleFiltering(msg))
return m, tea.Batch(cmds...)
}
2020-11-25 16:40:24 +00:00
// Updates per the current state
switch m.viewState {
case stashStateReady:
2020-11-25 16:40:24 +00:00
cmds = append(cmds, m.handleDocumentBrowsing(msg))
case stashStateShowingError:
// Any key exists the error view
if _, ok := msg.(tea.KeyMsg); ok {
m.viewState = stashStateReady
2020-11-25 16:40:24 +00:00
}
}
2020-11-25 16:40:24 +00:00
return m, tea.Batch(cmds...)
}
2020-12-01 03:12:05 +00:00
// Updates for when a user is browsing the markdown listing.
2020-11-25 16:40:24 +00:00
func (m *stashModel) handleDocumentBrowsing(msg tea.Msg) tea.Cmd {
var cmds []tea.Cmd
numDocs := len(m.getVisibleMarkdowns())
2020-11-25 16:40:24 +00:00
switch msg := msg.(type) {
// Handle keys
case tea.KeyMsg:
switch msg.String() {
case "k", "ctrl+k", "up":
2020-11-25 16:40:24 +00:00
m.moveCursorUp()
case "j", "ctrl+j", "down":
2020-11-25 16:40:24 +00:00
m.moveCursorDown()
// Go to the very start
case "home", "g":
m.paginator().Page = 0
m.setCursor(0)
2020-11-25 16:40:24 +00:00
// Go to the very end
case "end", "G":
m.paginator().Page = m.paginator().TotalPages - 1
m.setCursor(m.paginator().ItemsOnPage(numDocs) - 1)
2020-11-25 16:40:24 +00:00
2020-12-15 18:37:11 +00:00
// Clear filter (if applicable)
2022-10-25 14:40:51 +00:00
case keyEsc:
2020-12-15 18:37:11 +00:00
if m.filterApplied() {
m.resetFiltering()
}
2020-12-15 18:37:11 +00:00
// Next section
case "tab", "L":
2020-12-15 18:37:11 +00:00
if len(m.sections) == 0 || m.filterState == filtering {
break
}
m.sectionIndex++
if m.sectionIndex >= len(m.sections) {
m.sectionIndex = 0
}
m.updatePagination()
2020-12-15 18:37:11 +00:00
// Previous section
case "shift+tab", "H":
2020-12-15 18:37:11 +00:00
if len(m.sections) == 0 || m.filterState == filtering {
break
}
m.sectionIndex--
if m.sectionIndex < 0 {
m.sectionIndex = len(m.sections) - 1
}
m.updatePagination()
2020-08-21 17:39:59 +00:00
case "F":
m.loaded = false
return findLocalFiles(*m.common)
// Edit document in EDITOR
case "e":
md := m.selectedMarkdown()
return openEditor(md.localPath, 0)
2020-11-25 16:40:24 +00:00
// Open document
2022-10-25 14:40:51 +00:00
case keyEnter:
2020-11-25 16:40:24 +00:00
m.hideStatusMessage()
if numDocs == 0 {
2020-11-25 16:40:24 +00:00
break
}
2020-11-25 16:40:24 +00:00
// Load the document from the server. We'll handle the message
// that comes back in the main update function.
md := m.selectedMarkdown()
cmds = append(cmds, m.openMarkdown(md))
2020-11-19 23:56:46 +00:00
2020-11-25 16:40:24 +00:00
// Filter your notes
case "/":
m.hideStatusMessage()
2020-11-25 16:40:24 +00:00
// Build values we'll filter against
for _, md := range m.markdowns {
md.buildFilterValue()
}
m.filteredMarkdowns = m.markdowns
m.paginator().Page = 0
m.setCursor(0)
m.filterState = filtering
2020-11-25 16:40:24 +00:00
m.filterInput.CursorEnd()
m.filterInput.Focus()
return textinput.Blink
// Toggle full help
case "?":
m.showFullHelp = !m.showFullHelp
m.updatePagination()
2020-11-25 16:40:24 +00:00
// Show errors
case "!":
if m.err != nil && m.viewState == stashStateReady {
m.viewState = stashStateShowingError
2020-11-25 16:40:24 +00:00
return nil
}
}
2020-11-25 16:40:24 +00:00
}
2020-11-25 16:40:24 +00:00
// Update paginator. Pagination key handling is done here, but it could
// also be moved up to this level, in which case we'd use model methods
// like model.PageUp().
newPaginatorModel, cmd := m.paginator().Update(msg)
m.setPaginator(newPaginatorModel)
2020-11-25 16:40:24 +00:00
cmds = append(cmds, cmd)
// Extra paginator keystrokes
if key, ok := msg.(tea.KeyMsg); ok {
switch key.String() {
case "b", "u":
m.paginator().PrevPage()
2020-11-25 16:40:24 +00:00
case "f", "d":
m.paginator().NextPage()
}
2020-11-25 16:40:24 +00:00
}
2020-11-25 16:40:24 +00:00
// Keep the index in bounds when paginating
itemsOnPage := m.paginator().ItemsOnPage(len(m.getVisibleMarkdowns()))
if m.cursor() > itemsOnPage-1 {
m.setCursor(max(0, itemsOnPage-1))
2020-11-25 16:40:24 +00:00
}
2020-11-25 16:40:24 +00:00
return tea.Batch(cmds...)
}
2020-12-01 03:12:05 +00:00
// Updates for when a user is in the filter editing interface.
2020-11-25 16:40:24 +00:00
func (m *stashModel) handleFiltering(msg tea.Msg) tea.Cmd {
var cmds []tea.Cmd
2020-11-25 16:40:24 +00:00
// Handle keys
if msg, ok := msg.(tea.KeyMsg); ok {
switch msg.String() {
2022-10-25 14:40:51 +00:00
case keyEsc:
2020-11-25 16:40:24 +00:00
// Cancel filtering
m.resetFiltering()
2022-10-25 14:40:51 +00:00
case keyEnter, "tab", "shift+tab", "ctrl+k", "up", "ctrl+j", "down":
2020-11-25 16:40:24 +00:00
m.hideStatusMessage()
2020-11-25 16:40:24 +00:00
if len(m.markdowns) == 0 {
break
}
2020-11-25 16:40:24 +00:00
h := m.getVisibleMarkdowns()
2020-11-25 16:40:24 +00:00
// If we've filtered down to nothing, clear the filter
if len(h) == 0 {
m.viewState = stashStateReady
2020-11-25 16:40:24 +00:00
m.resetFiltering()
break
}
2020-11-25 16:40:24 +00:00
// When there's only one filtered markdown left we can just
// "open" it directly
if len(h) == 1 {
m.viewState = stashStateReady
2020-11-25 16:40:24 +00:00
m.resetFiltering()
cmds = append(cmds, m.openMarkdown(h[0]))
break
}
2020-12-15 18:37:11 +00:00
// Add new section if it's not present
if m.sections[len(m.sections)-1].key != filterSection {
m.sections = append(m.sections, sections[filterSection])
}
m.sectionIndex = len(m.sections) - 1
2020-11-25 16:40:24 +00:00
m.filterInput.Blur()
m.filterState = filterApplied
2020-11-25 16:40:24 +00:00
if m.filterInput.Value() == "" {
m.resetFiltering()
}
}
2020-11-25 16:40:24 +00:00
}
2020-11-25 16:40:24 +00:00
// Update the filter text input component
newFilterInputModel, inputCmd := m.filterInput.Update(msg)
currentFilterVal := m.filterInput.Value()
newFilterVal := newFilterInputModel.Value()
m.filterInput = newFilterInputModel
cmds = append(cmds, inputCmd)
2020-11-25 16:40:24 +00:00
// If the filtering input has changed, request updated filtering
if newFilterVal != currentFilterVal {
cmds = append(cmds, filterMarkdowns(*m))
}
2020-05-22 02:29:46 +00:00
2020-11-25 16:40:24 +00:00
// Update pagination
m.updatePagination()
2020-11-25 16:40:24 +00:00
return tea.Batch(cmds...)
}
2020-05-22 02:29:46 +00:00
// VIEW
2020-11-25 16:40:24 +00:00
func (m stashModel) view() string {
var s string
switch m.viewState {
case stashStateShowingError:
return errorView(m.err, false)
2020-05-15 19:08:45 +00:00
case stashStateLoadingDocument:
s += " " + m.spinner.View() + " Loading document..."
case stashStateReady:
loadingIndicator := " "
if m.shouldSpin() {
loadingIndicator = m.spinner.View()
}
// Only draw the normal header if we're not using the header area for
// something else (like a note or delete prompt).
header := m.headerView()
// Rules for the logo, filter and status message.
logoOrFilter := " "
2020-12-15 18:37:11 +00:00
if m.showStatusMessage && m.filterState == filtering {
logoOrFilter += m.statusMessage.String()
2020-12-15 18:37:11 +00:00
} else if m.filterState == filtering {
logoOrFilter += m.filterInput.View()
} else {
logoOrFilter += glowLogoView()
if m.showStatusMessage {
logoOrFilter += " " + m.statusMessage.String()
}
}
logoOrFilter = truncate.StringWithTail(logoOrFilter, uint(m.common.width-1), ellipsis)
help, helpHeight := m.helpView()
populatedView := m.populatedView()
populatedViewHeight := strings.Count(populatedView, "\n") + 2
// We need to fill any empty height with newlines so the footer reaches
// the bottom.
availHeight := m.common.height -
stashViewTopPadding -
populatedViewHeight -
helpHeight -
stashViewBottomPadding
blankLines := strings.Repeat("\n", max(0, availHeight))
var pagination string
if m.paginator().TotalPages > 1 {
pagination = m.paginator().View()
// If the dot pagination is wider than the width of the window
2021-03-01 22:57:54 +00:00
// use the arabic paginator.
if ansi.PrintableRuneWidth(pagination) > m.common.width-stashViewHorizontalPadding {
2021-03-01 22:57:54 +00:00
// Copy the paginator since m.paginator() returns a pointer to
// the active paginator and we don't want to mutate it. In
// normal cases, where the paginator is not a pointer, we could
// safely change the model parameters for rendering here as the
// current model is discarded after reuturning from a View().
// One could argue, in fact, that using pointers in
// a functional framework is an antipattern and our use of
// pointers in our model should be refactored away.
p := *(m.paginator())
2021-03-01 22:57:54 +00:00
p.Type = paginator.Arabic
pagination = paginationStyle.Render(p.View())
}
// We could also look at m.stashFullyLoaded and add an indicator
// showing that we don't actually know how many more pages there
// are.
}
2020-05-15 00:52:25 +00:00
s += fmt.Sprintf(
"%s%s\n\n %s\n\n%s\n\n%s %s\n\n%s",
loadingIndicator,
2020-11-13 21:33:22 +00:00
logoOrFilter,
2020-05-15 22:34:42 +00:00
header,
populatedView,
2020-05-15 01:12:13 +00:00
blankLines,
pagination,
help,
2020-05-15 00:52:25 +00:00
)
2020-05-13 23:02:39 +00:00
}
return "\n" + indent(s, stashIndent)
2020-05-13 23:02:39 +00:00
}
func glowLogoView() string {
return logoStyle.Render(" Glow ")
}
func (m stashModel) headerView() string {
localCount := len(m.markdowns)
2022-10-25 14:40:51 +00:00
var sections []string //nolint:prealloc
// Filter results
2020-12-15 18:37:11 +00:00
if m.filterState == filtering {
if localCount == 0 {
return grayFg("Nothing found.")
2021-03-12 12:30:30 +00:00
}
if localCount > 0 {
sections = append(sections, fmt.Sprintf("%d local", localCount))
}
for i := range sections {
sections[i] = grayFg(sections[i])
}
2023-05-05 09:40:36 +00:00
return strings.Join(sections, dividerDot.String())
}
// Tabs
for i, v := range m.sections {
var s string
switch v.key {
case documentsSection:
s = fmt.Sprintf("%d documents", localCount)
2020-12-15 18:37:11 +00:00
case filterSection:
s = fmt.Sprintf("%d “%s”", len(m.filteredMarkdowns), m.filterInput.Value())
}
if m.sectionIndex == i && len(m.sections) > 1 {
s = selectedTabStyle.Render(s)
} else {
s = tabStyle.Render(s)
}
sections = append(sections, s)
}
2020-10-25 03:57:12 +00:00
return strings.Join(sections, dividerBar.String())
2020-05-13 23:02:39 +00:00
}
func (m stashModel) populatedView() string {
mds := m.getVisibleMarkdowns()
var b strings.Builder
// Empty states
if len(mds) == 0 {
f := func(s string) {
b.WriteString(" " + grayFg(s))
}
switch m.sections[m.sectionIndex].key {
case documentsSection:
if m.loadingDone() {
f("No files found.")
} else {
f("Looking for local files...")
}
case filterSection:
return ""
}
}
if len(mds) > 0 {
start, end := m.paginator().GetSliceBounds(len(mds))
docs := mds[start:end]
2020-05-15 00:23:11 +00:00
2020-06-02 23:44:26 +00:00
for i, md := range docs {
stashItemView(&b, m, i, md)
if i != len(docs)-1 {
fmt.Fprintf(&b, "\n\n")
}
}
2020-05-13 23:02:39 +00:00
}
2020-05-15 00:52:25 +00:00
// If there aren't enough items to fill up this page (always the last page)
2020-06-02 23:44:26 +00:00
// then we need to add some newlines to fill up the space where stash items
// would have been.
itemsOnPage := m.paginator().ItemsOnPage(len(mds))
if itemsOnPage < m.paginator().PerPage {
n := (m.paginator().PerPage - itemsOnPage) * stashViewItemHeight
if len(mds) == 0 {
2020-06-02 23:44:26 +00:00
n -= stashViewItemHeight - 1
}
for i := 0; i < n; i++ {
fmt.Fprint(&b, "\n")
}
2020-05-15 00:52:25 +00:00
}
return b.String()
2020-05-15 00:23:11 +00:00
}
// COMMANDS
func loadLocalMarkdown(md *markdown) tea.Cmd {
return func() tea.Msg {
if md.localPath == "" {
return errMsg{errors.New("could not load file: missing path")}
}
2022-10-25 14:40:51 +00:00
data, err := os.ReadFile(md.localPath)
if err != nil {
log.Debug("error reading local file", "error", err)
return errMsg{err}
}
md.Body = string(data)
return fetchedMarkdownMsg(md)
}
}
func filterMarkdowns(m stashModel) tea.Cmd {
return func() tea.Msg {
2020-12-15 18:37:11 +00:00
if m.filterInput.Value() == "" || !m.filterApplied() {
return filteredMarkdownMsg(m.markdowns) // return everything
}
targets := []string{}
mds := m.markdowns
2020-11-25 16:40:24 +00:00
for _, t := range mds {
targets = append(targets, t.filterValue)
}
ranks := fuzzy.Find(m.filterInput.Value(), targets)
sort.Stable(ranks)
filtered := []*markdown{}
for _, r := range ranks {
2020-11-25 16:40:24 +00:00
filtered = append(filtered, mds[r.Index])
}
return filteredMarkdownMsg(filtered)
}
}