tools

main.go (4891B)

---

 package main
 
 import (
 	"cmp"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"
 	"time"
 )
 
 // caps how many content matches are collected per keystroke
 const resultLimit = 2000
 
 type doc struct {
 	src        string
 	rel        string
 	mtime      time.Time
 	lines      []string
 	linesLower []string
 }
 
 type match struct {
 	d    *doc
 	line int // 1-based, 0 in browse mode
 }
 
 func (m match) text() string {
 	if m.line == 0 {
 		return m.d.rel
 	}
 	return m.d.rel + ":" + strings.TrimSpace(m.d.lines[m.line-1])
 }
 
 type app struct {
 	base, txt string
 	scope     string
 	docs      []*doc
 
 	content bool
 	query   []rune
 	results []match
 	sel     int
 	top     int
 
 	rows, cols int
 	savedStty  string
 }
 
 func main() {
 	home, _ := os.UserHomeDir()
 	cache := cmp.Or(os.Getenv("XDG_CACHE_HOME"), filepath.Join(home, ".cache"))
 	a := &app{
 		base:    filepath.Join(home, "misc", "www"),
 		txt:     filepath.Join(cache, "wrd", "text"),
 		content: true,
 	}
 	if len(os.Args) > 1 && !strings.HasPrefix(os.Args[1], "-") {
 		a.scope = os.Args[1]
 	}
 
 	a.scan()
 	if len(a.docs) == 0 {
 		fmt.Fprintln(os.Stderr, "wrd: no pages under", a.base)
 		os.Exit(1)
 	}
 	a.index()
 	a.load()
 	a.run()
 }
 
 func (a *app) scan() {
 	_ = filepath.WalkDir(a.base, func(p string, d os.DirEntry, err error) error {
 		if err != nil || d.IsDir() {
 			return nil // skip unreadable entries, keep walking
 		}
 		ext := strings.ToLower(filepath.Ext(p))
 		if ext != ".html" && ext != ".md" {
 			return nil
 		}
 		rel, _ := filepath.Rel(a.base, p)
 		if a.scope != "" && !strings.Contains(rel, a.scope) {
 			return nil
 		}
 		fi, err := os.Stat(p)
 		if err != nil {
 			return nil // broken symlink or a vanished file
 		}
 		a.docs = append(a.docs, &doc{src: p, rel: rel, mtime: fi.ModTime()})
 		return nil
 	})
 }
 
 // index renders each page to a text cache, skipping ones already up to date
 func (a *app) index() {
 	type job struct{ src, out string }
 	var jobs []job
 	for _, d := range a.docs {
 		out := filepath.Join(a.txt, d.rel+".txt")
 		if oi, err := os.Stat(out); err == nil &&
 			!d.mtime.Truncate(time.Second).After(oi.ModTime().Truncate(time.Second)) {
 			continue
 		}
 		jobs = append(jobs, job{d.src, out})
 	}
 	if len(jobs) == 0 {
 		return
 	}
 
 	fmt.Fprintf(os.Stderr, "indexing %d pages\n", len(jobs))
 	ch := make(chan job)
 	var wg sync.WaitGroup
 	for range runtime.NumCPU() {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			for j := range ch {
 				if err := render(j.src, j.out); err != nil {
 					fmt.Fprintf(os.Stderr, "wrd: %s: %v\n", j.src, err)
 				}
 			}
 		}()
 	}
 	for _, j := range jobs {
 		ch <- j
 	}
 	close(ch)
 	wg.Wait()
 }
 
 func render(src, out string) error {
 	fi, err := os.Stat(src)
 	if err != nil {
 		return err
 	}
 	if err := os.MkdirAll(filepath.Dir(out), 0o755); err != nil {
 		return err
 	}
 	f, err := os.Create(out)
 	if err != nil {
 		return err
 	}
 
 	html := strings.EqualFold(filepath.Ext(src), ".html")
 	cmd := exec.Command("pandoc", "-t", "plain", src)
 	if html {
 		cmd = exec.Command("cha", "-d", src)
 	}
 	cmd.Stdout = f
 	rerr := cmd.Run()
 	if rerr != nil && !html { // fall back to the raw markdown
 		_, _ = f.Seek(0, 0)
 		_ = f.Truncate(0)
 		if b, e := os.ReadFile(src); e == nil {
 			_, _ = f.Write(b)
 			rerr = nil
 		}
 	}
 	_ = f.Close()
 
 	if rerr != nil {
 		_ = os.Remove(out)
 		return rerr
 	}
 	_ = os.Chtimes(out, time.Now(), fi.ModTime())
 	return nil
 }
 
 func (a *app) load() {
 	for _, d := range a.docs {
 		b, err := os.ReadFile(filepath.Join(a.txt, d.rel+".txt"))
 		if err != nil {
 			continue
 		}
 		s := strings.TrimRight(string(b), "\n")
 		if strings.TrimSpace(s) == "" {
 			continue // missing or empty render: leave it as no-text
 		}
 		d.lines = strings.Split(s, "\n")
 		d.linesLower = make([]string, len(d.lines))
 		for i, ln := range d.lines {
 			d.linesLower[i] = strings.ToLower(ln)
 		}
 	}
 }
 
 func (a *app) search() {
 	q := strings.TrimSpace(string(a.query))
 	fold := q == strings.ToLower(q) // lowercase query => case-insensitive
 	a.results = a.results[:0]
 
 	switch {
 	case a.content && q == "":
 	case a.content:
 		for _, d := range a.docs {
 			lines := d.lines
 			if fold {
 				lines = d.linesLower
 			}
 			for i, ln := range lines {
 				if strings.Contains(ln, q) {
 					a.results = append(a.results, match{d, i + 1})
 					if len(a.results) >= resultLimit {
 						goto done
 					}
 				}
 			}
 		}
 	default:
 		for _, d := range a.docs {
 			hay := d.rel
 			if fold {
 				hay = strings.ToLower(hay)
 			}
 			if fuzzy(hay, q) {
 				a.results = append(a.results, match{d: d})
 			}
 		}
 	}
 done:
 	a.sel = max(0, min(a.sel, len(a.results)-1))
 	a.top = 0
 }
 
 func fuzzy(hay, needle string) bool {
 	nr := []rune(needle)
 	i := 0
 	for _, c := range hay {
 		if i == len(nr) {
 			break
 		}
 		if c == nr[i] {
 			i++
 		}
 	}
 	return i == len(nr)
 }
 
 func url(rel string) string {
 	rel = strings.TrimSuffix(rel, "/index.html")
 	rel = strings.TrimSuffix(rel, "index.html")
 	return "https://" + rel
 }