🏃 🤫 📚
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

278 lines
6.7 KiB

// go-sh-manymanuals TODO
package main
import (
"flag"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/charmbracelet/bubbles/textinput"
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
pdf "github.com/johbar/go-poppler"
"github.com/sahilm/fuzzy"
)
// filenameFilterMode searches by PDF file name.
const filenameFilterMode = "filename"
// contentFilterMode searches by PDF contents.
const contentFilterMode = "content"
// help is the command-line interface help output.
const help = `go-sh-manymanuals: TODO
TODO
Options:
-h output help
`
// minCharsUntilFilter is the minimum amount of characters that are
// required before the filtering logic commences actually filtering.
const minCharsUntilFilter = 2
// helpFlag is the help flag for the command-line interface.
var helpFlag bool
// handleCliFlags handles command-line flags.
func handleCliFlags() {
flag.BoolVar(&helpFlag, "h", false, "output help")
flag.Parse()
}
// readPDF reads the plain text contents of a PDF. This does not include the
// formatting. Only the content you see when you view it through a PDF reader.
// The library we're using makes use of the C bindings to the Poppler PDF
// library https://poppler.freedesktop.org which appears to offer a good mix of
// reliability and effectiveness.
func readPDF(name string) (string, error) {
doc, err := pdf.Open(name)
if err != nil {
return "", err
}
defer doc.Close()
var txt string
for i := 0; i < doc.GetNPages(); i++ {
txt += doc.GetPage(i).Text()
}
return txt, nil
}
// model offers the core of the state for the entire UI.
type model struct {
input textinput.Model // Fuzzy search interface
datasheets []datasheet // All datasheets under cwd
datasheetNames []string // All datasheet names (caching)
filteredDatasheets []string // Filtered view on all datasheets
datasheetViewport viewport.Model // Viewport for the PDF content
filterMode string // The filtering mode ("filename", "content")
}
// datasheetFromName retrieves a datasheet via a name.
func (m model) datasheetFromName(name string) string {
for _, d := range m.datasheets {
if d.filename == name {
return d.contents
}
}
return ""
}
// toggleFilterMode toggles the filter mode.
func (m *model) toggleFilterMode() {
if m.filterMode == filenameFilterMode {
m.filterMode = contentFilterMode
} else {
m.filterMode = filenameFilterMode
}
}
// datasheet represents a datasheet on disk.
type datasheet struct {
filename string // The name of the file
absPath string // the absolute file path
contents string // the contents of the PDF
}
// initialModel constucts an initial state for the UI.
func initialModel() model {
input := textinput.New()
input.Focus()
var datasheets []datasheet
var datasheetNames []string
// TODO: handle error in interface?
_ = filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
name := info.Name()
if strings.HasSuffix(name, "pdf") {
// TODO: handle error in interface?
// TODO: don't read them all up front while blocking?
// we could run this in a goroutine somewhere
// this currently slows down startup time
contents, _ := readPDF(path)
datasheet := datasheet{
filename: name,
absPath: path,
contents: contents,
}
datasheets = append(datasheets, datasheet)
datasheetNames = append(datasheetNames, name)
}
return nil
})
// TODO: set width/heigh to match terminal. this should also
// be set in relation to the list of filenames also. they
// should have some visually pleasing ratio set i imagine
viewp := viewport.New(60, 30)
selectedDatasheet := datasheets[len(datasheets)-1].contents
viewp.SetContent(selectedDatasheet)
m := model{
input: input,
datasheets: datasheets,
datasheetNames: datasheetNames,
filteredDatasheets: datasheetNames,
datasheetViewport: viewp,
filterMode: filenameFilterMode,
}
return m
}
// Init initialises the program.
func (m model) Init() tea.Cmd {
return textinput.Blink
}
// filterDatasheetNames filters datasheet names based on user input.
func filterDatasheetNames(m model) []string {
search := m.input.Value()
if !(len(search) >= minCharsUntilFilter) {
return m.datasheetNames
}
var matchedDatasheets []string
matches := fuzzy.Find(search, m.datasheetNames)
for _, match := range matches {
matchedDatasheets = append(matchedDatasheets, match.Str)
}
if len(matches) > 0 {
return matchedDatasheets
}
return m.datasheetNames
}
// Update updates the program state.
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
var (
cmd tea.Cmd
cmds []tea.Cmd
)
if m.input.Focused() {
m.filteredDatasheets = filterDatasheetNames(m)
// TODO: implement cursor for scrolling up/down filtered
// results so we can view the PDF contents as desired
// it's currently just the last one (closest to input)
lastdatasheet := m.filteredDatasheets[len(m.filteredDatasheets)-1]
viewportText := m.datasheetFromName(lastdatasheet)
m.datasheetViewport.SetContent(viewportText)
}
// TODO: handle terminal resizing
switch msg := msg.(type) {
case tea.KeyMsg:
switch msg.String() {
case "ctrl+c":
return m, tea.Quit
case "tab":
m.toggleFilterMode()
}
}
m.input, cmd = m.input.Update(msg)
cmds = append(cmds, cmd)
m.datasheetViewport, cmd = m.datasheetViewport.Update(msg)
cmds = append(cmds, cmd)
return m, tea.Batch(cmds...)
}
// View outputs the program state for viewing.
func (m model) View() string {
body := strings.Builder{}
// TODO: paginate / trim view to last 10 or something?
sheets := strings.Join(m.filteredDatasheets, "\n")
// TODO: style further with lipgloss, e.g. borders, margins, etc.
panes := lipgloss.JoinHorizontal(lipgloss.Left, sheets, m.datasheetViewport.View())
body.WriteString(panes)
body.WriteString("\n" + m.input.View())
mode := "filter: "
if m.filterMode == filenameFilterMode {
mode += "filename"
} else {
// TODO make this mode actually work once we figure out bleve
mode += "content (FIXME)"
}
body.WriteString("\n" + mode)
help := "[ctrl-c]: quit | [tab]: filter mode"
body.WriteString("\n" + help)
return body.String()
}
// main is the command-line entrypoint.
func main() {
handleCliFlags()
if helpFlag {
fmt.Printf(help)
os.Exit(0)
}
f, err := tea.LogToFile("debug.log", "debug")
if err != nil {
fmt.Println("fatal:", err)
os.Exit(1)
}
defer f.Close()
p := tea.NewProgram(
initialModel(),
tea.WithAltScreen(),
tea.WithMouseCellMotion(),
)
if err := p.Start(); err != nil {
fmt.Printf("oops, something went wrong: %v", err)
os.Exit(1)
}
}